zignet/dist/model-downloader-ioH3AphD.cjs

MCP server for Zig — AI-powered code analysis, validation, and documentation with fine-tuned LLM

const require_chunk = require('./chunk-DWy1uDak.cjs');
const require_config = require('./config-C2ufArDU.cjs');
let node_path = require("node:path");
node_path = require_chunk.__toESM(node_path);
let node_fs_promises = require("node:fs/promises");
node_fs_promises = require_chunk.__toESM(node_fs_promises);
let node_fs = require("node:fs");
node_fs = require_chunk.__toESM(node_fs);
let node_stream = require("node:stream");
node_stream = require_chunk.__toESM(node_stream);

//#region src/llm/model-downloader.ts
const MODEL_REPO = "fulgidus/zignet-qwen2.5-coder-7b";
const MODEL_FILE = "gguf/zignet-qwen-7b-q4km.gguf";
const MODEL_SIZE_MB = 4400;
var ModelDownloader = class {
	modelPath;
	constructor() {
		this.modelPath = require_config.MODEL_PATH;
	}
	/**
	* Get the path to the model file
	*/
	getModelPath() {
		return this.modelPath;
	}
	/**
	* Check if model is already downloaded
	*/
	isModelAvailable() {
		return (0, node_fs.existsSync)(this.modelPath);
	}
	/**
	* Download the GGUF model from HuggingFace
	*/
	async downloadModel(onProgress) {
		if (this.isModelAvailable()) {
			console.log("✅ Model already downloaded:", this.modelPath);
			return;
		}
		console.log("📥 Downloading ZigNet model from HuggingFace...");
		console.log(`📦 Size: ${MODEL_SIZE_MB}MB`);
		console.log(`📍 Repo: ${MODEL_REPO}`);
		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(this.modelPath), { recursive: true });
		const url = `https://huggingface.co/${MODEL_REPO}/resolve/main/${MODEL_FILE}`;
		try {
			const response = await fetch(url);
			if (!response.ok) throw new Error(`Failed to download model: ${response.statusText}`);
			const totalBytes = parseInt(response.headers.get("content-length") || "0", 10);
			if (!response.body) throw new Error("Response body is null");
			const fileStream = (0, node_fs.createWriteStream)(this.modelPath);
			let downloadedBytes = 0;
			const nodeStream = node_stream.Readable.fromWeb(response.body);
			nodeStream.on("data", (chunk) => {
				downloadedBytes += chunk.length;
				if (onProgress && totalBytes > 0) onProgress({
					downloaded: downloadedBytes,
					total: totalBytes,
					percent: downloadedBytes / totalBytes * 100
				});
			});
			await new Promise((resolve, reject) => {
				nodeStream.pipe(fileStream);
				nodeStream.on("error", reject);
				fileStream.on("error", reject);
				fileStream.on("finish", resolve);
			});
			console.log("✅ Model downloaded successfully!");
			console.log(`📁 Location: ${this.modelPath}`);
		} catch (error) {
			if ((0, node_fs.existsSync)(this.modelPath)) await (0, node_fs_promises.unlink)(this.modelPath);
			throw new Error(`Failed to download model: ${error instanceof Error ? error.message : String(error)}`);
		}
	}
	/**
	* Ensure model is downloaded, download if needed
	*/
	async ensureModel(onProgress) {
		if (!this.isModelAvailable()) await this.downloadModel(onProgress);
		return this.modelPath;
	}
};
/**
* Singleton instance
*/
const modelDownloader = new ModelDownloader();

//#endregion
Object.defineProperty(exports, 'ModelDownloader', {
  enumerable: true,
  get: function () {
    return ModelDownloader;
  }
});
Object.defineProperty(exports, 'modelDownloader', {
  enumerable: true,
  get: function () {
    return modelDownloader;
  }
});
//# sourceMappingURL=model-downloader-ioH3AphD.cjs.map