wrapture 0.0.1

package/bin/wrapture.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+// src/wrapture.ts
+import chalk2 from "chalk";
+import { Command } from "commander";
+import { existsSync } from "node:fs";
+import path3 from "node:path";
+
+// src/utils/convert.ts
+import chalk from "chalk";
+import ora from "ora";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path, { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var convert = async (inputPath, outputDir, opts) => {
+  if (!fs.existsSync(inputPath)) {
+    throw new Error(`Input model file not found: ${inputPath}`);
+  }
+  const spinner = ora("\u{1F504} Converting model to ONNX...").start();
+  return new Promise((resolve, reject) => {
+    const scriptPath = path.resolve(__dirname, "../../python/convert.py");
+    const args = [
+      scriptPath,
+      "--input",
+      inputPath,
+      "--output",
+      outputDir,
+      "--format",
+      opts.format || "onnx"
+    ];
+    if (opts.quantize) args.push("--quantize");
+    const python = spawn("python3", args);
+    python.stdout.on("data", (data) => process.stdout.write(data));
+    python.stderr.on(
+      "data",
+      (data) => process.stderr.write(chalk.red(data.toString()))
+    );
+    python.on("close", (code) => {
+      if (code === 0) {
+        spinner.succeed("\u2705 Model converted successfully.");
+        resolve();
+      } else {
+        spinner.fail("\u274C Model conversion failed.");
+        reject(new Error(`convert.py exited with code ${code}`));
+      }
+    });
+  });
+};
+
+// src/utils/generate-wrapper.ts
+import ora2 from "ora";
+import fs2 from "node:fs";
+import path2 from "node:path";
+var generateWrapper = async (outputDir, opts) => {
+  const spinner = ora2("\u{1F6E0} Generating wrapper files...").start();
+  const wrapper = `import { InferenceSession, Tensor } from 'onnxruntime-web';
+
+const softmax = (logits) => {
+  const exps = logits.map(Math.exp);
+  const sum = exps.reduce((a, b) => a + b, 0);
+  return exps.map(e => e / sum);
+}
+
+const argmax = (arr) => {
+  return arr.reduce((maxIdx, val, idx, src) => val > src[maxIdx] ? idx : maxIdx, 0);
+}
+
+export const loadModel = async () => {
+   const session = await InferenceSession.create(
+    new URL('./${opts.backend === "wasm" ? "model_quant.onnx" : "model.onnx"}', import.meta.url).href
+  );
+  return {
+    predict: async (input) => {
+      const feeds = { input: new Tensor('float32', input.data, input.dims) };
+      const results = await session.run(feeds);
+      const raw = results.output.data;
+
+      if (!(raw instanceof Float32Array)) {
+        throw new Error('Expected Float32Array logits but got something else');
+      }
+
+      const logits = raw;
+      const probabilities = softmax(Array.from(logits));
+      const predictedClass = argmax(probabilities);
+      return { logits, probabilities, predictedClass };
+    }
+  };
+};
+`;
+  const typings = `export interface ModelInput {
+  data: Float32Array;
+  dims: number[];
+}
+
+export interface ModelOutput {
+  logits: Float32Array;
+  probabilities: number[];
+  predictedClass: number;
+}
+
+export interface LoadedModel {
+  predict(input: ModelInput): Promise<ModelOutput>;
+}
+
+/**
+ * Load the ONNX model and return a wrapper with \`predict()\` function.
+ */
+export function loadModel(): Promise<LoadedModel>;`;
+  try {
+    fs2.writeFileSync(path2.join(outputDir, "wrapped.ts"), wrapper);
+    fs2.writeFileSync(path2.join(outputDir, "wrapped.d.ts"), typings);
+    spinner.succeed("\u2705 Wrapper files generated.");
+  } catch (error) {
+    spinner.fail("\u274C Failed to generate wrapper files.");
+    throw error;
+  }
+};
+
+// src/wrapture.ts
+var program = new Command();
+program.name("wrapture").description("\u{1F300} One-click model exporter: from PyTorch to Web-ready JS/TS").version("0.1.0").requiredOption("-i, --input <file>", "Path to the PyTorch model (.pt)").requiredOption(
+  "-o, --output <dir>",
+  "Output directory for the wrapped model"
+).option("--quantize", "Apply quantization to reduce model size").option("--format <type>", "Export format: onnx (default)", "onnx").option(
+  "--backend <backend>",
+  "Inference backend: webgpu | wasm | cpu",
+  "webgpu"
+).action(async (opts) => {
+  const input = path3.resolve(opts.input);
+  const output = path3.resolve(opts.output);
+  if (!existsSync(input)) {
+    console.error(chalk2.red(`Input file not found: ${input}`));
+    process.exit(1);
+  }
+  console.log(chalk2.cyan("\u2728 Wrapture: Exporting model..."));
+  try {
+    await convert(input, output, opts);
+    await generateWrapper(output, opts);
+    console.log(chalk2.green("\u2705 Done! Your model is wrapped and ready."));
+  } catch (err) {
+    console.error(chalk2.red("\u274C Failed to export model:"), err);
+    process.exit(1);
+  }
+});
+program.parse(process.argv);

package/custom-typedoc-plugin.js

@@ -0,0 +1,55 @@
+/* eslint-disable import/no-unused-modules */
+import { MarkdownTheme, MarkdownThemeContext } from 'typedoc-plugin-markdown';
+
+/**
+ * @param {import('typedoc-plugin-markdown').MarkdownApplication} app
+ */
+export function load(app) {
+  app.renderer.defineTheme('custom-markdown-theme', MyMarkdownTheme);
+
+  app.renderer.markdownHooks.on(
+    'content.begin',
+    () => `> Last updated ${new Date().toISOString()}`
+  );
+
+  const footerText = `***
+
+**Contributing**
+
+Want to contribute? Please read the [CONTRIBUTING.md](https://github.com/phun-ky/wrapture/blob/main/CONTRIBUTING.md) and [CODE_OF_CONDUCT.md](https://github.com/phun-ky/wrapture/blob/main/CODE_OF_CONDUCT.md)
+
+**Sponsor me**
+
+I'm an Open Source evangelist, creating stuff that does not exist yet to help get rid of secondary activities and to enhance systems already in place, be it documentation or web sites.
+
+The sponsorship is an unique opportunity to alleviate more hours for me to maintain my projects, create new ones and contribute to the large community we're all part of :)
+
+[Support me on GitHub Sponsors](https://github.com/sponsors/phun-ky).
+
+***
+
+This project created by [Alexander Vassbotn Røyne-Helgesen](http://phun-ky.net) is licensed under a [MIT License](https://choosealicense.com/licenses/mit/).
+`;
+
+  app.renderer.markdownHooks.on('page.end', () => footerText);
+
+  app.renderer.markdownHooks.on('index.page.end', () => footerText);
+}
+
+class MyMarkdownTheme extends MarkdownTheme {
+  /**
+   * @param {import('typedoc-plugin-markdown').MarkdownPageEvent} page
+   */
+  getRenderContext(page) {
+    return new MyMarkdownThemeContext(this, page, this.application.options);
+  }
+}
+
+class MyMarkdownThemeContext extends MarkdownThemeContext {
+  partials = {
+    ...this.partials,
+    header: () => {
+      return '';
+    }
+  };
+}

package/eslint.config.mjs

@@ -0,0 +1,16 @@
+import { defineConfig } from 'eslint/config';
+import customConfig from 'eslint-config-phun-ky';
+
+// eslint-disable-next-line import/no-unused-modules
+export default defineConfig([
+  {
+    extends: [customConfig]
+  },
+  {
+    files: ['**/*.md'],
+    rules: {
+      'no-irregular-whitespace': 'off',
+      '@stylistic/indent': 'off'
+    }
+  }
+]);

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "wrapture",
+  "version": "0.0.1",
+  "description": "",
+  "homepage": "https://github.com/phun-ky/wrapture#readme",
+  "bugs": {
+    "url": "https://github.com/phun-ky/wrapture/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/phun-ky/wrapture.git"
+  },
+  "funding": "https://github.com/phun-ky/angle?sponsor=1",
+  "license": "MIT",
+  "author": "Alexander Vassbotn Røyne-Helgesen <alexander@phun-ky.net>",
+  "type": "module",
+  "bin": {
+    "wrapture": "./bin/wrapture.js"
+  },
+  "scripts": {
+    "commit": "npx git-cz",
+    "docs:gen": "node ./node_modules/.bin/typedoc",
+    "release": "release-it",
+    "start": "node ./bin/wrapture.js",
+    "build": "tsup",
+    "style:code": "npx putout src",
+    "style:format": "./node_modules/.bin/eslint -c ./eslint.config.mjs src  --fix && ./node_modules/.bin/prettier --write ./eslint.config.mjs src",
+    "style:lint": "./node_modules/.bin/eslint -c ./eslint.config.mjs src && ./node_modules/.bin/prettier --check src",
+    "test": "NODE_ENV=test glob -c \"node --import tsx --test --no-warnings\" \"./src/**/__tests__/**/*.[jt]s\"",
+    "pretest:ci": "rm -rf coverage && mkdir -p coverage",
+    "test:ci": "NODE_ENV=test glob -c \"node --import tsx --test --no-warnings --experimental-test-coverage --test-reporter=cobertura --test-reporter-destination=coverage/cobertura-coverage.xml --test-reporter=spec --test-reporter-destination=stdout\" \"./src/**/__tests__/**/*.[jt]s\""
+  },
+  "engines": {
+    "node": ">=22.0.0",
+    "npm": ">=10.8.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@release-it/conventional-changelog": "^10.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@stylistic/eslint-plugin": "^4.2.0",
+    "@types/node": "^22.15.3",
+    "cobertura": "^1.0.1",
+    "eslint": "^9.20.0",
+    "eslint-config-phun-ky": "^1.0.0",
+    "git-cz": "^4.9.0",
+    "onnxruntime-web": "^1.22.0",
+    "prettier": "^3.2.5",
+    "putout": "^40.1.9",
+    "release-it": "^19.0.1",
+    "remark-github": "^12.0.0",
+    "remark-toc": "^9.0.0",
+    "tslib": "^2.3.1",
+    "tsup": "^8.4.0",
+    "tsx": "^4.7.1",
+    "typedoc": "^0.28.3",
+    "typedoc-plugin-frontmatter": "^1.0.0",
+    "typedoc-plugin-markdown": "^4.2.3",
+    "typedoc-plugin-mdn-links": "^5.0.1",
+    "typedoc-plugin-no-inherit": "^1.4.0",
+    "typedoc-plugin-remark": "^2.0.0",
+    "typedoc-plugin-rename-defaults": "^0.7.1",
+    "typescript": "^5.0.0",
+    "unified-prettier": "^2.0.1"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "ora": "^8.2.0"
+  }
+}

package/public/docs/README.md

@@ -0,0 +1 @@
+# wrapture API documentation

package/python/convert.py

@@ -0,0 +1,72 @@
+import argparse
+import torch
+import torch.nn as nn
+import os
+from onnxsim import simplify
+import onnx
+from onnxruntime.quantization import quantize_dynamic, QuantType
+
+def convert_to_onnx(input_path, output_path, quantize=False):
+    class BasicCNN(nn.Module):  # Define the same model architecture
+        def __init__(self):
+            super().__init__()
+            self.net = nn.Sequential(
+                nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1),
+                nn.ReLU(),
+                nn.AdaptiveAvgPool2d((1, 1)),
+                nn.Flatten(),
+                nn.Linear(16, 10)
+            )
+
+        def forward(self, x):
+            return self.net(x)
+
+    model = BasicCNN()
+
+    model.load_state_dict(torch.load(input_path, map_location='cpu', weights_only=False))
+
+    model.eval()
+
+    dummy_input = torch.randn(1, 3, 224, 224)
+    output_model_path = os.path.join(output_path, 'model.onnx')
+    torch.onnx.export(
+        model,
+        dummy_input,
+        output_model_path,
+        input_names=['input'],
+        output_names=['output'],
+        dynamic_axes={'input': {0: 'batch_size'}, 'output': {0: 'batch_size'}},
+        opset_version=11
+    )
+    model = onnx.load(output_model_path)
+    model_simp, check = simplify(model)
+    assert check, "Simplified model could not be validated"
+    onnx.checker.check_model(model_simp)  # throw if broken
+    onnx.save(model_simp, output_model_path)
+    print("✅ ONNX model simplified.")
+
+    print(f"✅ Exported ONNX model to: {output_model_path}")
+
+    if quantize:
+        quant_model_path = os.path.join(output_path, 'model_quant.onnx')
+        quantize_dynamic(output_model_path, quant_model_path, weight_type=QuantType.QInt8)
+
+def main():
+    parser = argparse.ArgumentParser(description='Wrapture: Convert PyTorch model to ONNX.')
+    parser.add_argument('--input', required=True, help='Path to the PyTorch model (.pt)')
+    parser.add_argument('--output', required=True, help='Directory to save the ONNX model')
+    parser.add_argument('--format', default='onnx', help='Export format (currently only supports ONNX)')
+    parser.add_argument('--quantize', action='store_true', help='Apply quantization')
+
+    args = parser.parse_args()
+
+    if not os.path.exists(args.output):
+        os.makedirs(args.output)
+
+    if args.format.lower() == 'onnx':
+        convert_to_onnx(args.input, args.output, args.quantize)
+    else:
+        raise ValueError(f"Unsupported format: {args.format}")
+
+if __name__ == '__main__':
+    main()

package/python/scripts/basic_model.py

@@ -0,0 +1,20 @@
+import torch
+import torch.nn as nn
+
+class BasicCNN(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(),
+            nn.AdaptiveAvgPool2d((1, 1)),
+            nn.Flatten(),
+            nn.Linear(16, 10)
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+model = BasicCNN()
+torch.save(model.state_dict(), 'test/fixtures/basic_model.pt')
+print("✅ Saved model weights to test/fixtures/basic_model.pt")

package/scripts/test.ts

@@ -0,0 +1,11 @@
+/* eslint-disable no-console */
+import { loadModel } from '../wrapped.js';
+
+const model = await loadModel();
+const input = {
+  data: new Float32Array(1 * 3 * 224 * 224),
+  dims: [1, 3, 224, 224]
+};
+const out = await model.predict(input);
+
+console.log(out);

package/src/utils/__tests__/convert.unit.ts

@@ -0,0 +1,47 @@
+// test/convert.test.js
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import path, { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { convert } from '../convert';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const fixtureModelPath = path.resolve('test', 'fixtures', 'basic_model.pt');
+const outputDir = path.join(tmpdir(), `wrapture-test-${randomUUID()}`);
+
+test('convert() should reject if file does not exist', async () => {
+  const nonExistentPath = 'some/missing/model.pt';
+  const invalidOut = path.join(tmpdir(), `wrapture-test-${randomUUID()}`);
+
+  await assert.rejects(
+    () => convert(nonExistentPath, invalidOut, {}),
+    /Input model file not found/i
+  );
+});
+
+test('convert() resolves if subprocess exits cleanly', async (t) => {
+  // Mock subprocess call by making convert.py short-circuit if needed
+  const mockInput = fixtureModelPath;
+  const output = outputDir;
+
+  // Make sure the output dir exists
+  fs.mkdirSync(output, { recursive: true });
+
+  // You can only run this if the python script exists and is safe to test
+  // Skip the test if script is missing or too slow
+  const scriptPath = path.resolve(__dirname, '../../../python', 'convert.py');
+  if (!fs.existsSync(scriptPath)) {
+    t.skip('Python script does not exist, skipping subprocess test');
+    return;
+  }
+
+  await assert.doesNotReject(async () => {
+    await convert(mockInput, output, { format: 'onnx', quantize: false });
+  });
+});

package/src/utils/__tests__/generate-wrapper.unit.ts

@@ -0,0 +1,29 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { generateWrapper } from '../generate-wrapper.js';
+
+const testOutputDir = './.test-output';
+
+test('generateWrapper creates wrapper files', async (t) => {
+  // Clean up previous run
+  fs.rmSync(testOutputDir, { recursive: true, force: true });
+  fs.mkdirSync(testOutputDir);
+
+  await generateWrapper(testOutputDir, { backend: 'webgpu' });
+
+  const files = fs.readdirSync(testOutputDir);
+  assert.ok(files.includes('wrapped.ts'), 'wrapped.ts should be generated');
+  assert.ok(files.includes('wrapped.d.ts'), 'wrapped.d.ts should be generated');
+
+  const wrapperContent = fs.readFileSync(
+    path.join(testOutputDir, 'wrapped.ts'),
+    'utf-8'
+  );
+  assert.match(
+    wrapperContent,
+    /loadModel/,
+    'Wrapper should contain loadModel function'
+  );
+});

package/src/utils/convert.ts

@@ -0,0 +1,98 @@
+/* eslint-disable import/no-unused-modules */
+/* global process */
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path, { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Options for the {@link convert} function.
+ */
+export interface ConvertOptionsInterface {
+  /**
+   * The output format for the converted model (e.g., 'onnx').
+   * Defaults to 'onnx' if not provided.
+   */
+  format?: string;
+
+  /**
+   * Whether to apply quantization to the model.
+   */
+  quantize?: boolean;
+}
+
+/**
+ * Converts a machine learning model to ONNX or another supported format
+ * by delegating to a Python script (`convert.py`).
+ *
+ * This function spawns a subprocess using `python3` and monitors stdout/stderr.
+ * It supports additional options such as format selection and quantization.
+ *
+ * @function convert
+ * @param {string} inputPath - Path to the input model file
+ * @param {string} outputDir - Directory where the converted model should be saved
+ * @param {ConvertOptionsInterface} opts - Conversion options
+ * @returns A promise that resolves on success or rejects if conversion fails
+ *
+ * @throws {Error} If the Python process exits with a non-zero code
+ *
+ * @example
+ * ```ts
+ * await convert('models/model.pt', 'out/', { format: 'onnx', quantize: true });
+ * ```
+ *
+ * @see https://nodejs.org/api/child_process.html#child_processspawncommand-args-options
+ * @see https://github.com/sindresorhus/ora - Ora spinner for CLI feedback
+ * @see https://github.com/chalk/chalk - Chalk for terminal coloring
+ */
+export const convert = async (
+  inputPath: string,
+  outputDir: string,
+  opts: ConvertOptionsInterface
+): Promise<void> => {
+  if (!fs.existsSync(inputPath)) {
+    throw new Error(`Input model file not found: ${inputPath}`);
+  }
+
+  const spinner = ora('🔄 Converting model to ONNX...').start();
+
+  return new Promise((resolve, reject) => {
+    const scriptPath = path.resolve(__dirname, '../../python/convert.py');
+    const args = [
+      scriptPath,
+      '--input',
+      inputPath,
+      '--output',
+      outputDir,
+      '--format',
+      opts.format || 'onnx'
+    ];
+
+    if (opts.quantize) args.push('--quantize');
+
+    const python = spawn('python3', args);
+
+    python.stdout.on('data', (data) => process.stdout.write(data));
+    python.stderr.on('data', (data) =>
+      process.stderr.write(chalk.red(data.toString()))
+    );
+
+    python.on('close', (code) => {
+      if (code === 0) {
+        spinner.succeed('✅ Model converted successfully.');
+
+        resolve();
+      } else {
+        spinner.fail('❌ Model conversion failed.');
+
+        reject(new Error(`convert.py exited with code ${code}`));
+      }
+    });
+  });
+};

package/src/utils/generate-wrapper.ts

@@ -0,0 +1,107 @@
+import ora from 'ora';
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Options for generating ONNX wrapper files.
+ */
+export interface GenerateWrapperOptionsInterface {
+  /**
+   * The backend to use for inference. This affects the model file used.
+   * If set to `'wasm'`, the generated wrapper will load `model_quant.onnx`,
+   * otherwise it will load `model.onnx`.
+   */
+  backend: 'wasm' | 'webgl' | string;
+}
+
+/**
+ * Generates a TypeScript wrapper and type definition file (`wrapped.ts` and `wrapped.d.ts`)
+ * for use with `onnxruntime-web`, including utility functions like `softmax`, `argmax`,
+ * and a typed `predict()` function.
+ *
+ * The generated code loads the correct ONNX model based on the provided backend.
+ *
+ * @param {string} outputDir - The directory where the wrapper files will be written.
+ * @param {GenerateWrapperOptionsInterface} opts - Wrapper generation options, including backend type.
+ * @returns A Promise that resolves when the wrapper files are successfully written.
+ *
+ * @throws Will throw an error if file writing fails.
+ *
+ * @example
+ * ```ts
+ * await generateWrapper('./dist', { backend: 'wasm' });
+ * // Creates `wrapped.ts` and `wrapped.d.ts` in ./dist
+ * ```
+ *
+ * @see https://www.npmjs.com/package/onnxruntime-web
+ */
+export const generateWrapper = async (
+  outputDir: string,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  opts: GenerateWrapperOptionsInterface
+): Promise<void> => {
+  const spinner = ora('🛠 Generating wrapper files...').start();
+  const wrapper = `import { InferenceSession, Tensor } from 'onnxruntime-web';
+
+const softmax = (logits) => {
+  const exps = logits.map(Math.exp);
+  const sum = exps.reduce((a, b) => a + b, 0);
+  return exps.map(e => e / sum);
+}
+
+const argmax = (arr) => {
+  return arr.reduce((maxIdx, val, idx, src) => val > src[maxIdx] ? idx : maxIdx, 0);
+}
+
+export const loadModel = async () => {
+   const session = await InferenceSession.create(
+    new URL('./${opts.backend === 'wasm' ? 'model_quant.onnx' : 'model.onnx'}', import.meta.url).href
+  );
+  return {
+    predict: async (input) => {
+      const feeds = { input: new Tensor('float32', input.data, input.dims) };
+      const results = await session.run(feeds);
+      const raw = results.output.data;
+
+      if (!(raw instanceof Float32Array)) {
+        throw new Error('Expected Float32Array logits but got something else');
+      }
+
+      const logits = raw;
+      const probabilities = softmax(Array.from(logits));
+      const predictedClass = argmax(probabilities);
+      return { logits, probabilities, predictedClass };
+    }
+  };
+};
+`;
+  const typings = `export interface ModelInput {
+  data: Float32Array;
+  dims: number[];
+}
+
+export interface ModelOutput {
+  logits: Float32Array;
+  probabilities: number[];
+  predictedClass: number;
+}
+
+export interface LoadedModel {
+  predict(input: ModelInput): Promise<ModelOutput>;
+}
+
+/**
+ * Load the ONNX model and return a wrapper with \`predict()\` function.
+ */
+export function loadModel(): Promise<LoadedModel>;`;
+
+  try {
+    fs.writeFileSync(path.join(outputDir, 'wrapped.ts'), wrapper);
+    fs.writeFileSync(path.join(outputDir, 'wrapped.d.ts'), typings);
+    spinner.succeed('✅ Wrapper files generated.');
+  } catch (error) {
+    spinner.fail('❌ Failed to generate wrapper files.');
+    throw error;
+  }
+};