alepha 0.11.10 → 0.11.11

package/dist/index.js

@@ -5,15 +5,16 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import cluster from "node:cluster";
 import { cpus } from "node:os";
 import * as fs from "node:fs/promises";
-import { access, cp, glob, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { access, copyFile, cp, glob, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { stdin, stdout } from "node:process";
 import { createInterface } from "node:readline/promises";
 import { exec, spawn } from "node:child_process";
-import { Readable } from "node:stream";
-import { pipeline } from "stream/promises";
+import { PassThrough, Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createReadStream, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 import * as tar from "tar";
-import { readFileSync } from "node:fs";
 import { tsImport } from "tsx/esm/api";
 
 //#region rolldown:runtime
@@ -14796,7 +14797,8 @@ var CliProvider = class {
 					run: runner.run,
 					ask: this.asker.ask,
 					fs,
-					glob
+					glob,
+					root: process.cwd()
 				};
 				await command.options.handler(args);
 				if (command.options.summary !== false) runner.summary();
@@ -15007,42 +15009,6 @@ const AlephaCommand = $module({
 	]
 });
 
-//#endregion
-//#region src/assets/biomeJson.ts
-const biomeJson = `
-{
-  "$schema": "https://biomejs.dev/schemas/latest/schema.json",
-  "vcs": {
-    "enabled": true,
-    "clientKind": "git"
-  },
-  "files": {
-    "ignoreUnknown": true,
-    "includes": ["**", "!node_modules", "!dist"]
-  },
-  "formatter": {
-    "enabled": true,
-    "indentStyle": "space"
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "recommended": true
-    },
-    "domains": {
-      "react": "recommended"
-    }
-  },
-  "assist": {
-    "actions": {
-      "source": {
-        "organizeImports": "on"
-      }
-    }
-  }
-}
-`.trim();
-
 //#endregion
 //#region src/services/ProcessRunner.ts
 /**
@@ -15111,18 +15077,1567 @@ var ProcessRunner = class {
 	}
 };
 
+//#endregion
+//#region ../file/src/providers/FileSystemProvider.ts
+/**
+* FileSystem interface providing utilities for working with files.
+*/
+var FileSystemProvider = class {};
+
+//#endregion
+//#region ../file/src/services/FileDetector.ts
+/**
+* Service for detecting file types and getting content types.
+*
+* @example
+* ```typescript
+* const detector = alepha.inject(FileDetector);
+*
+* // Get content type from filename
+* const mimeType = detector.getContentType("image.png"); // "image/png"
+*
+* // Detect file type by magic bytes
+* const stream = createReadStream('image.png');
+* const result = await detector.detectFileType(stream, 'image.png');
+* console.log(result.mimeType); // 'image/png'
+* console.log(result.verified); // true if magic bytes match
+* ```
+*/
+var FileDetector = class FileDetector {
+	/**
+	* Magic byte signatures for common file formats.
+	* Each signature is represented as an array of bytes or null (wildcard).
+	*/
+	static MAGIC_BYTES = {
+		png: [{
+			signature: [
+				137,
+				80,
+				78,
+				71,
+				13,
+				10,
+				26,
+				10
+			],
+			mimeType: "image/png"
+		}],
+		jpg: [
+			{
+				signature: [
+					255,
+					216,
+					255,
+					224
+				],
+				mimeType: "image/jpeg"
+			},
+			{
+				signature: [
+					255,
+					216,
+					255,
+					225
+				],
+				mimeType: "image/jpeg"
+			},
+			{
+				signature: [
+					255,
+					216,
+					255,
+					226
+				],
+				mimeType: "image/jpeg"
+			},
+			{
+				signature: [
+					255,
+					216,
+					255,
+					227
+				],
+				mimeType: "image/jpeg"
+			},
+			{
+				signature: [
+					255,
+					216,
+					255,
+					232
+				],
+				mimeType: "image/jpeg"
+			}
+		],
+		jpeg: [
+			{
+				signature: [
+					255,
+					216,
+					255,
+					224
+				],
+				mimeType: "image/jpeg"
+			},
+			{
+				signature: [
+					255,
+					216,
+					255,
+					225
+				],
+				mimeType: "image/jpeg"
+			},
+			{
+				signature: [
+					255,
+					216,
+					255,
+					226
+				],
+				mimeType: "image/jpeg"
+			},
+			{
+				signature: [
+					255,
+					216,
+					255,
+					227
+				],
+				mimeType: "image/jpeg"
+			},
+			{
+				signature: [
+					255,
+					216,
+					255,
+					232
+				],
+				mimeType: "image/jpeg"
+			}
+		],
+		gif: [{
+			signature: [
+				71,
+				73,
+				70,
+				56,
+				55,
+				97
+			],
+			mimeType: "image/gif"
+		}, {
+			signature: [
+				71,
+				73,
+				70,
+				56,
+				57,
+				97
+			],
+			mimeType: "image/gif"
+		}],
+		webp: [{
+			signature: [
+				82,
+				73,
+				70,
+				70,
+				null,
+				null,
+				null,
+				null,
+				87,
+				69,
+				66,
+				80
+			],
+			mimeType: "image/webp"
+		}],
+		bmp: [{
+			signature: [66, 77],
+			mimeType: "image/bmp"
+		}],
+		ico: [{
+			signature: [
+				0,
+				0,
+				1,
+				0
+			],
+			mimeType: "image/x-icon"
+		}],
+		tiff: [{
+			signature: [
+				73,
+				73,
+				42,
+				0
+			],
+			mimeType: "image/tiff"
+		}, {
+			signature: [
+				77,
+				77,
+				0,
+				42
+			],
+			mimeType: "image/tiff"
+		}],
+		tif: [{
+			signature: [
+				73,
+				73,
+				42,
+				0
+			],
+			mimeType: "image/tiff"
+		}, {
+			signature: [
+				77,
+				77,
+				0,
+				42
+			],
+			mimeType: "image/tiff"
+		}],
+		pdf: [{
+			signature: [
+				37,
+				80,
+				68,
+				70,
+				45
+			],
+			mimeType: "application/pdf"
+		}],
+		zip: [
+			{
+				signature: [
+					80,
+					75,
+					3,
+					4
+				],
+				mimeType: "application/zip"
+			},
+			{
+				signature: [
+					80,
+					75,
+					5,
+					6
+				],
+				mimeType: "application/zip"
+			},
+			{
+				signature: [
+					80,
+					75,
+					7,
+					8
+				],
+				mimeType: "application/zip"
+			}
+		],
+		rar: [{
+			signature: [
+				82,
+				97,
+				114,
+				33,
+				26,
+				7
+			],
+			mimeType: "application/vnd.rar"
+		}],
+		"7z": [{
+			signature: [
+				55,
+				122,
+				188,
+				175,
+				39,
+				28
+			],
+			mimeType: "application/x-7z-compressed"
+		}],
+		tar: [{
+			signature: [
+				117,
+				115,
+				116,
+				97,
+				114
+			],
+			mimeType: "application/x-tar"
+		}],
+		gz: [{
+			signature: [31, 139],
+			mimeType: "application/gzip"
+		}],
+		tgz: [{
+			signature: [31, 139],
+			mimeType: "application/gzip"
+		}],
+		mp3: [
+			{
+				signature: [255, 251],
+				mimeType: "audio/mpeg"
+			},
+			{
+				signature: [255, 243],
+				mimeType: "audio/mpeg"
+			},
+			{
+				signature: [255, 242],
+				mimeType: "audio/mpeg"
+			},
+			{
+				signature: [
+					73,
+					68,
+					51
+				],
+				mimeType: "audio/mpeg"
+			}
+		],
+		wav: [{
+			signature: [
+				82,
+				73,
+				70,
+				70,
+				null,
+				null,
+				null,
+				null,
+				87,
+				65,
+				86,
+				69
+			],
+			mimeType: "audio/wav"
+		}],
+		ogg: [{
+			signature: [
+				79,
+				103,
+				103,
+				83
+			],
+			mimeType: "audio/ogg"
+		}],
+		flac: [{
+			signature: [
+				102,
+				76,
+				97,
+				67
+			],
+			mimeType: "audio/flac"
+		}],
+		mp4: [
+			{
+				signature: [
+					null,
+					null,
+					null,
+					null,
+					102,
+					116,
+					121,
+					112
+				],
+				mimeType: "video/mp4"
+			},
+			{
+				signature: [
+					null,
+					null,
+					null,
+					null,
+					102,
+					116,
+					121,
+					112,
+					105,
+					115,
+					111,
+					109
+				],
+				mimeType: "video/mp4"
+			},
+			{
+				signature: [
+					null,
+					null,
+					null,
+					null,
+					102,
+					116,
+					121,
+					112,
+					109,
+					112,
+					52,
+					50
+				],
+				mimeType: "video/mp4"
+			}
+		],
+		webm: [{
+			signature: [
+				26,
+				69,
+				223,
+				163
+			],
+			mimeType: "video/webm"
+		}],
+		avi: [{
+			signature: [
+				82,
+				73,
+				70,
+				70,
+				null,
+				null,
+				null,
+				null,
+				65,
+				86,
+				73,
+				32
+			],
+			mimeType: "video/x-msvideo"
+		}],
+		mov: [{
+			signature: [
+				null,
+				null,
+				null,
+				null,
+				102,
+				116,
+				121,
+				112,
+				113,
+				116,
+				32,
+				32
+			],
+			mimeType: "video/quicktime"
+		}],
+		mkv: [{
+			signature: [
+				26,
+				69,
+				223,
+				163
+			],
+			mimeType: "video/x-matroska"
+		}],
+		docx: [{
+			signature: [
+				80,
+				75,
+				3,
+				4
+			],
+			mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+		}],
+		xlsx: [{
+			signature: [
+				80,
+				75,
+				3,
+				4
+			],
+			mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+		}],
+		pptx: [{
+			signature: [
+				80,
+				75,
+				3,
+				4
+			],
+			mimeType: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+		}],
+		doc: [{
+			signature: [
+				208,
+				207,
+				17,
+				224,
+				161,
+				177,
+				26,
+				225
+			],
+			mimeType: "application/msword"
+		}],
+		xls: [{
+			signature: [
+				208,
+				207,
+				17,
+				224,
+				161,
+				177,
+				26,
+				225
+			],
+			mimeType: "application/vnd.ms-excel"
+		}],
+		ppt: [{
+			signature: [
+				208,
+				207,
+				17,
+				224,
+				161,
+				177,
+				26,
+				225
+			],
+			mimeType: "application/vnd.ms-powerpoint"
+		}]
+	};
+	/**
+	* All possible format signatures for checking against actual file content
+	*/
+	static ALL_SIGNATURES = Object.entries(FileDetector.MAGIC_BYTES).flatMap(([ext, signatures]) => signatures.map((sig) => ({
+		ext,
+		...sig
+	})));
+	/**
+	* MIME type map for file extensions.
+	*
+	* Can be used to get the content type of file based on its extension.
+	* Feel free to add more mime types in your project!
+	*/
+	static mimeMap = {
+		json: "application/json",
+		txt: "text/plain",
+		html: "text/html",
+		htm: "text/html",
+		xml: "application/xml",
+		csv: "text/csv",
+		pdf: "application/pdf",
+		md: "text/markdown",
+		markdown: "text/markdown",
+		rtf: "application/rtf",
+		css: "text/css",
+		js: "application/javascript",
+		mjs: "application/javascript",
+		ts: "application/typescript",
+		jsx: "text/jsx",
+		tsx: "text/tsx",
+		zip: "application/zip",
+		rar: "application/vnd.rar",
+		"7z": "application/x-7z-compressed",
+		tar: "application/x-tar",
+		gz: "application/gzip",
+		tgz: "application/gzip",
+		png: "image/png",
+		jpg: "image/jpeg",
+		jpeg: "image/jpeg",
+		gif: "image/gif",
+		webp: "image/webp",
+		svg: "image/svg+xml",
+		bmp: "image/bmp",
+		ico: "image/x-icon",
+		tiff: "image/tiff",
+		tif: "image/tiff",
+		mp3: "audio/mpeg",
+		wav: "audio/wav",
+		ogg: "audio/ogg",
+		m4a: "audio/mp4",
+		aac: "audio/aac",
+		flac: "audio/flac",
+		mp4: "video/mp4",
+		webm: "video/webm",
+		avi: "video/x-msvideo",
+		mov: "video/quicktime",
+		wmv: "video/x-ms-wmv",
+		flv: "video/x-flv",
+		mkv: "video/x-matroska",
+		doc: "application/msword",
+		docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+		xls: "application/vnd.ms-excel",
+		xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+		ppt: "application/vnd.ms-powerpoint",
+		pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+		woff: "font/woff",
+		woff2: "font/woff2",
+		ttf: "font/ttf",
+		otf: "font/otf",
+		eot: "application/vnd.ms-fontobject"
+	};
+	/**
+	* Returns the content type of file based on its filename.
+	*
+	* @param filename - The filename to check
+	* @returns The MIME type
+	*
+	* @example
+	* ```typescript
+	* const detector = alepha.inject(FileDetector);
+	* const mimeType = detector.getContentType("image.png"); // "image/png"
+	* ```
+	*/
+	getContentType(filename) {
+		const ext = filename.toLowerCase().split(".").pop() || "";
+		return FileDetector.mimeMap[ext] || "application/octet-stream";
+	}
+	/**
+	* Detects the file type by checking magic bytes against the stream content.
+	*
+	* @param stream - The readable stream to check
+	* @param filename - The filename (used to get the extension)
+	* @returns File type information including MIME type, extension, and verification status
+	*
+	* @example
+	* ```typescript
+	* const detector = alepha.inject(FileDetector);
+	* const stream = createReadStream('image.png');
+	* const result = await detector.detectFileType(stream, 'image.png');
+	* console.log(result.mimeType); // 'image/png'
+	* console.log(result.verified); // true if magic bytes match
+	* ```
+	*/
+	async detectFileType(stream, filename) {
+		const expectedMimeType = this.getContentType(filename);
+		const lastDotIndex = filename.lastIndexOf(".");
+		const ext = lastDotIndex > 0 ? filename.substring(lastDotIndex + 1).toLowerCase() : "";
+		const { buffer, stream: newStream } = await this.peekBytes(stream, 16);
+		const expectedSignatures = FileDetector.MAGIC_BYTES[ext];
+		if (expectedSignatures) {
+			for (const { signature, mimeType } of expectedSignatures) if (this.matchesSignature(buffer, signature)) return {
+				mimeType,
+				extension: ext,
+				verified: true,
+				stream: newStream
+			};
+		}
+		for (const { ext: detectedExt, signature, mimeType } of FileDetector.ALL_SIGNATURES) if (detectedExt !== ext && this.matchesSignature(buffer, signature)) return {
+			mimeType,
+			extension: detectedExt,
+			verified: true,
+			stream: newStream
+		};
+		return {
+			mimeType: expectedMimeType,
+			extension: ext,
+			verified: false,
+			stream: newStream
+		};
+	}
+	/**
+	* Reads all bytes from a stream and returns the first N bytes along with a new stream containing all data.
+	* This approach reads the entire stream upfront to avoid complex async handling issues.
+	*
+	* @protected
+	*/
+	async peekBytes(stream, numBytes) {
+		const chunks = [];
+		for await (const chunk of stream) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+		const allData = Buffer.concat(chunks);
+		return {
+			buffer: allData.subarray(0, numBytes),
+			stream: Readable.from(allData)
+		};
+	}
+	/**
+	* Checks if a buffer matches a magic byte signature.
+	*
+	* @protected
+	*/
+	matchesSignature(buffer, signature) {
+		if (buffer.length < signature.length) return false;
+		for (let i = 0; i < signature.length; i++) if (signature[i] !== null && buffer[i] !== signature[i]) return false;
+		return true;
+	}
+};
+
+//#endregion
+//#region ../file/src/providers/NodeFileSystemProvider.ts
+/**
+* Node.js implementation of FileSystem interface.
+*
+* @example
+* ```typescript
+* const fs = alepha.inject(NodeFileSystemProvider);
+*
+* // Create from URL
+* const file1 = fs.createFile({ url: "file:///path/to/file.png" });
+*
+* // Create from Buffer
+* const file2 = fs.createFile({ buffer: Buffer.from("hello"), name: "hello.txt" });
+*
+* // Create from text
+* const file3 = fs.createFile({ text: "Hello, world!", name: "greeting.txt" });
+*
+* // File operations
+* await fs.mkdir("/tmp/mydir", { recursive: true });
+* await fs.cp("/src/file.txt", "/dest/file.txt");
+* await fs.mv("/old/path.txt", "/new/path.txt");
+* const files = await fs.ls("/tmp");
+* await fs.rm("/tmp/file.txt");
+* ```
+*/
+var NodeFileSystemProvider = class {
+	detector = $inject(FileDetector);
+	/**
+	* Creates a FileLike object from various sources.
+	*
+	* @param options - Options for creating the file
+	* @returns A FileLike object
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* // From URL
+	* const file1 = fs.createFile({ url: "https://example.com/image.png" });
+	*
+	* // From Buffer
+	* const file2 = fs.createFile({
+	*   buffer: Buffer.from("hello"),
+	*   name: "hello.txt",
+	*   type: "text/plain"
+	* });
+	*
+	* // From text
+	* const file3 = fs.createFile({ text: "Hello!", name: "greeting.txt" });
+	*
+	* // From stream with detection
+	* const stream = createReadStream("/path/to/file.png");
+	* const file4 = fs.createFile({ stream, name: "image.png" });
+	* ```
+	*/
+	createFile(options) {
+		if ("url" in options) return this.createFileFromUrl(options.url, {
+			type: options.type,
+			name: options.name
+		});
+		if ("file" in options) return this.createFileFromWebFile(options.file, {
+			type: options.type,
+			name: options.name,
+			size: options.size
+		});
+		if ("buffer" in options) return this.createFileFromBuffer(options.buffer, {
+			type: options.type,
+			name: options.name
+		});
+		if ("arrayBuffer" in options) return this.createFileFromBuffer(Buffer.from(options.arrayBuffer), {
+			type: options.type,
+			name: options.name
+		});
+		if ("text" in options) return this.createFileFromBuffer(Buffer.from(options.text, "utf-8"), {
+			type: options.type || "text/plain",
+			name: options.name || "file.txt"
+		});
+		if ("stream" in options) return this.createFileFromStream(options.stream, {
+			type: options.type,
+			name: options.name,
+			size: options.size
+		});
+		throw new AlephaError("Invalid createFile options: no valid source provided");
+	}
+	/**
+	* Removes a file or directory.
+	*
+	* @param path - The path to remove
+	* @param options - Remove options
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* // Remove a file
+	* await fs.rm("/tmp/file.txt");
+	*
+	* // Remove a directory recursively
+	* await fs.rm("/tmp/mydir", { recursive: true });
+	*
+	* // Remove with force (no error if doesn't exist)
+	* await fs.rm("/tmp/maybe-exists.txt", { force: true });
+	* ```
+	*/
+	async rm(path, options) {
+		await rm(path, options);
+	}
+	/**
+	* Copies a file or directory.
+	*
+	* @param src - Source path
+	* @param dest - Destination path
+	* @param options - Copy options
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* // Copy a file
+	* await fs.cp("/src/file.txt", "/dest/file.txt");
+	*
+	* // Copy a directory recursively
+	* await fs.cp("/src/dir", "/dest/dir", { recursive: true });
+	*
+	* // Copy with force (overwrite existing)
+	* await fs.cp("/src/file.txt", "/dest/file.txt", { force: true });
+	* ```
+	*/
+	async cp(src, dest, options) {
+		if ((await stat(src)).isDirectory()) {
+			if (!options?.recursive) throw new Error(`Cannot copy directory without recursive option: ${src}`);
+			await cp(src, dest, {
+				recursive: true,
+				force: options?.force ?? false
+			});
+		} else await copyFile(src, dest);
+	}
+	/**
+	* Moves/renames a file or directory.
+	*
+	* @param src - Source path
+	* @param dest - Destination path
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* // Move/rename a file
+	* await fs.mv("/old/path.txt", "/new/path.txt");
+	*
+	* // Move a directory
+	* await fs.mv("/old/dir", "/new/dir");
+	* ```
+	*/
+	async mv(src, dest) {
+		await rename(src, dest);
+	}
+	/**
+	* Creates a directory.
+	*
+	* @param path - The directory path to create
+	* @param options - Mkdir options
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* // Create a directory
+	* await fs.mkdir("/tmp/mydir");
+	*
+	* // Create nested directories
+	* await fs.mkdir("/tmp/path/to/dir", { recursive: true });
+	*
+	* // Create with specific permissions
+	* await fs.mkdir("/tmp/mydir", { mode: 0o755 });
+	* ```
+	*/
+	async mkdir(path, options) {
+		await mkdir(path, options);
+	}
+	/**
+	* Lists files in a directory.
+	*
+	* @param path - The directory path to list
+	* @param options - List options
+	* @returns Array of filenames
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* // List files in a directory
+	* const files = await fs.ls("/tmp");
+	* console.log(files); // ["file1.txt", "file2.txt", "subdir"]
+	*
+	* // List with hidden files
+	* const allFiles = await fs.ls("/tmp", { hidden: true });
+	*
+	* // List recursively
+	* const allFilesRecursive = await fs.ls("/tmp", { recursive: true });
+	* ```
+	*/
+	async ls(path, options) {
+		const entries = await readdir(path);
+		const filteredEntries = options?.hidden ? entries : entries.filter((e) => !e.startsWith("."));
+		if (options?.recursive) {
+			const allFiles = [];
+			for (const entry of filteredEntries) {
+				const fullPath = join(path, entry);
+				if ((await stat(fullPath)).isDirectory()) {
+					allFiles.push(entry);
+					const subFiles = await this.ls(fullPath, options);
+					allFiles.push(...subFiles.map((f) => join(entry, f)));
+				} else allFiles.push(entry);
+			}
+			return allFiles;
+		}
+		return filteredEntries;
+	}
+	/**
+	* Checks if a file or directory exists.
+	*
+	* @param path - The path to check
+	* @returns True if the path exists, false otherwise
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* if (await fs.exists("/tmp/file.txt")) {
+	*   console.log("File exists");
+	* }
+	* ```
+	*/
+	async exists(path) {
+		try {
+			await access(path);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Reads the content of a file.
+	*
+	* @param path - The file path to read
+	* @returns The file content as a Buffer
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* const buffer = await fs.readFile("/tmp/file.txt");
+	* console.log(buffer.toString("utf-8"));
+	* ```
+	*/
+	async readFile(path) {
+		return await readFile(path);
+	}
+	/**
+	* Writes data to a file.
+	*
+	* @param path - The file path to write to
+	* @param data - The data to write (Buffer or string)
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* // Write string
+	* await fs.writeFile("/tmp/file.txt", "Hello, world!");
+	*
+	* // Write Buffer
+	* await fs.writeFile("/tmp/file.bin", Buffer.from([0x01, 0x02, 0x03]));
+	* ```
+	*/
+	async writeFile(path, data) {
+		await writeFile(path, data);
+	}
+	/**
+	* Creates a FileLike object from a Web File.
+	*
+	* @protected
+	*/
+	createFileFromWebFile(source, options = {}) {
+		const name = options.name ?? source.name;
+		return {
+			name,
+			type: options.type ?? (source.type || this.detector.getContentType(name)),
+			size: options.size ?? source.size ?? 0,
+			lastModified: source.lastModified || Date.now(),
+			stream: () => source.stream(),
+			arrayBuffer: async () => {
+				return await source.arrayBuffer();
+			},
+			text: async () => {
+				return await source.text();
+			}
+		};
+	}
+	/**
+	* Creates a FileLike object from a Buffer.
+	*
+	* @protected
+	*/
+	createFileFromBuffer(source, options = {}) {
+		const name = options.name ?? "file";
+		return {
+			name,
+			type: options.type ?? this.detector.getContentType(options.name ?? name),
+			size: source.byteLength,
+			lastModified: Date.now(),
+			stream: () => Readable.from(source),
+			arrayBuffer: async () => {
+				return this.bufferToArrayBuffer(source);
+			},
+			text: async () => {
+				return source.toString("utf-8");
+			}
+		};
+	}
+	/**
+	* Creates a FileLike object from a stream.
+	*
+	* @protected
+	*/
+	createFileFromStream(source, options = {}) {
+		let buffer = null;
+		return {
+			name: options.name ?? "file",
+			type: options.type ?? this.detector.getContentType(options.name ?? "file"),
+			size: options.size ?? 0,
+			lastModified: Date.now(),
+			stream: () => source,
+			_buffer: null,
+			arrayBuffer: async () => {
+				buffer ??= await this.streamToBuffer(source);
+				return this.bufferToArrayBuffer(buffer);
+			},
+			text: async () => {
+				buffer ??= await this.streamToBuffer(source);
+				return buffer.toString("utf-8");
+			}
+		};
+	}
+	/**
+	* Creates a FileLike object from a URL.
+	*
+	* @protected
+	*/
+	createFileFromUrl(url, options = {}) {
+		const parsedUrl = new URL(url);
+		const filename = options.name || parsedUrl.pathname.split("/").pop() || "file";
+		let buffer = null;
+		return {
+			name: filename,
+			type: options.type ?? this.detector.getContentType(filename),
+			size: 0,
+			lastModified: Date.now(),
+			stream: () => this.createStreamFromUrl(url),
+			arrayBuffer: async () => {
+				buffer ??= await this.loadFromUrl(url);
+				return this.bufferToArrayBuffer(buffer);
+			},
+			text: async () => {
+				buffer ??= await this.loadFromUrl(url);
+				return buffer.toString("utf-8");
+			},
+			filepath: url
+		};
+	}
+	/**
+	* Gets a streaming response from a URL.
+	*
+	* @protected
+	*/
+	getStreamingResponse(url) {
+		const stream = new PassThrough();
+		fetch(url).then((res) => Readable.fromWeb(res.body).pipe(stream)).catch((err) => stream.destroy(err));
+		return stream;
+	}
+	/**
+	* Loads data from a URL.
+	*
+	* @protected
+	*/
+	async loadFromUrl(url) {
+		const parsedUrl = new URL(url);
+		if (parsedUrl.protocol === "file:") return await readFile(fileURLToPath(url));
+		else if (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:") {
+			const response = await fetch(url);
+			if (!response.ok) throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+			const arrayBuffer = await response.arrayBuffer();
+			return Buffer.from(arrayBuffer);
+		} else throw new Error(`Unsupported protocol: ${parsedUrl.protocol}`);
+	}
+	/**
+	* Creates a stream from a URL.
+	*
+	* @protected
+	*/
+	createStreamFromUrl(url) {
+		const parsedUrl = new URL(url);
+		if (parsedUrl.protocol === "file:") return createReadStream(fileURLToPath(url));
+		else if (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:") return this.getStreamingResponse(url);
+		else throw new AlephaError(`Unsupported protocol: ${parsedUrl.protocol}`);
+	}
+	/**
+	* Converts a stream-like object to a Buffer.
+	*
+	* @protected
+	*/
+	async streamToBuffer(streamLike) {
+		const stream = streamLike instanceof Readable ? streamLike : Readable.fromWeb(streamLike);
+		return new Promise((resolve, reject) => {
+			const buffer = [];
+			stream.on("data", (chunk) => buffer.push(Buffer.from(chunk)));
+			stream.on("end", () => resolve(Buffer.concat(buffer)));
+			stream.on("error", (err) => reject(new AlephaError("Error converting stream", { cause: err })));
+		});
+	}
+	/**
+	* Converts a Node.js Buffer to an ArrayBuffer.
+	*
+	* @protected
+	*/
+	bufferToArrayBuffer(buffer) {
+		return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+	}
+};
+
+//#endregion
+//#region ../file/src/index.ts
+/**
+* Provides file system capabilities for Alepha applications with support for multiple file sources and operations.
+*
+* The file module enables working with files from various sources (URLs, buffers, streams) and provides
+* utilities for file type detection, content type determination, and common file system operations.
+*
+* @see {@link FileDetector}
+* @see {@link FileSystemProvider}
+* @see {@link NodeFileSystemProvider}
+* @module alepha.file
+*/
+const AlephaFile = $module({
+	name: "alepha.file",
+	descriptors: [],
+	services: [
+		FileDetector,
+		FileSystemProvider,
+		NodeFileSystemProvider
+	],
+	register: (alepha$1) => alepha$1.with({
+		optional: true,
+		provide: FileSystemProvider,
+		use: NodeFileSystemProvider
+	})
+});
+
+//#endregion
+//#region src/assets/biomeJson.ts
+const biomeJson = `
+{
+  "$schema": "https://biomejs.dev/schemas/latest/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git"
+  },
+  "files": {
+    "ignoreUnknown": true,
+    "includes": ["**", "!node_modules", "!dist"]
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space"
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    },
+    "domains": {
+      "react": "recommended"
+    }
+  },
+  "assist": {
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
+  }
+}
+`.trim();
+
+//#endregion
+//#region src/assets/tsconfigJson.ts
+const tsconfigJson = `
+{
+  "compilerOptions": {
+    "module": "nodenext",
+    "target": "esnext",
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true
+  },
+  "exclude": ["node_modules", "dist"]
+}
+`.trim();
+
+//#endregion
+//#region src/assets/viteConfigTs.ts
+const viteConfigTs = (serverEntry) => `
+import { viteAlepha } from "@alepha/vite";
+
+export default {
+  plugins: [
+    viteAlepha(${serverEntry ? `{ serverEntry: "${serverEntry}" }` : ""}),
+  ],
+  test: {
+    globals: true,
+  },
+};
+`.trim();
+
+//#endregion
+//#region src/version.ts
+const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+const version = packageJson.version;
+
+//#endregion
+//#region src/services/ProjectUtils.ts
+/**
+* Utility service for common project operations used by CLI commands.
+*
+* This service provides helper methods for:
+* - Project configuration file management (tsconfig.json, package.json, etc.)
+* - Package manager setup (Yarn, npm, pnpm)
+* - Sample project downloading
+* - Drizzle ORM/Kit utilities
+* - Alepha instance loading
+*/
+var ProjectUtils = class {
+	log = $logger();
+	runner = $inject(ProcessRunner);
+	fs = $inject(FileSystemProvider);
+	/**
+	* Ensure Yarn is configured in the project directory.
+	*
+	* Creates a .yarnrc.yml file with node-modules linker if it doesn't exist.
+	*
+	* @param root - The root directory of the project
+	*/
+	async ensureYarn(root) {
+		const yarnrcPath = join(root, ".yarnrc.yml");
+		try {
+			await access(yarnrcPath);
+		} catch {
+			await writeFile(yarnrcPath, "nodeLinker: node-modules");
+		}
+		const npmLockPath = join(root, "package-lock.json");
+		const pnpmLockPath = join(root, "pnpm-lock.yaml");
+		await this.fs.rm(npmLockPath, { force: true });
+		await this.fs.rm(pnpmLockPath, { force: true });
+	}
+	/**
+	* Generate package.json content with Alepha dependencies.
+	*
+	* @param modes - Configuration for which dependencies to include
+	* @returns Package.json partial with dependencies, devDependencies, and scripts
+	*/
+	generatePackageJsonContent(modes) {
+		const dependencies = {
+			"@alepha/core": `^${version}`,
+			"@alepha/logger": `^${version}`,
+			"@alepha/datetime": `^${version}`
+		};
+		const devDependencies = {
+			alepha: `^${version}`,
+			"@alepha/vite": `^${version}`
+		};
+		if (modes.api) {
+			dependencies["@alepha/server"] = `^${version}`;
+			dependencies["@alepha/server-swagger"] = `^${version}`;
+			dependencies["@alepha/server-multipart"] = `^${version}`;
+		}
+		if (modes.orm) dependencies["@alepha/orm"] = `^${version}`;
+		if (modes.react) {
+			dependencies["@alepha/server"] = `^${version}`;
+			dependencies["@alepha/server-links"] = `^${version}`;
+			dependencies["@alepha/react"] = `^${version}`;
+			dependencies.react = "^19.2.0";
+			devDependencies["@types/react"] = "^19.2.0";
+		}
+		return {
+			dependencies,
+			devDependencies,
+			scripts: {
+				dev: "alepha dev",
+				build: "alepha build"
+			}
+		};
+	}
+	/**
+	* Ensure package.json exists and has correct configuration.
+	*
+	* Creates a new package.json if none exists, or updates an existing one to:
+	* - Set "type": "module"
+	* - Add Alepha dependencies
+	* - Add standard scripts
+	*
+	* @param root - The root directory of the project
+	* @param modes - Configuration for which dependencies to include
+	*/
+	async ensurePackageJson(root, modes) {
+		const packageJsonPath = join(root, "package.json");
+		try {
+			await access(packageJsonPath);
+		} catch (error) {
+			await writeFile(packageJsonPath, JSON.stringify(this.generatePackageJsonContent(modes), null, 2));
+			return;
+		}
+		const content = await readFile(packageJsonPath, "utf8");
+		const packageJson$1 = JSON.parse(content);
+		if (!packageJson$1.type || packageJson$1.type !== "module") packageJson$1.type = "module";
+		const newPackageJson = this.generatePackageJsonContent(modes);
+		packageJson$1.type = "module";
+		packageJson$1.dependencies ??= {};
+		packageJson$1.devDependencies ??= {};
+		packageJson$1.scripts ??= {};
+		Object.assign(packageJson$1.dependencies, newPackageJson.dependencies);
+		Object.assign(packageJson$1.devDependencies, newPackageJson.devDependencies);
+		Object.assign(packageJson$1.scripts, newPackageJson.scripts);
+		await writeFile(packageJsonPath, JSON.stringify(packageJson$1, null, 2));
+	}
+	/**
+	* Ensure package.json exists and is configured as ES module.
+	*
+	* Similar to ensurePackageJson but only validates/sets the "type": "module" field.
+	* Throws an error if no package.json exists.
+	*
+	* @param root - The root directory of the project
+	* @throws {AlephaError} If no package.json is found
+	*/
+	async ensurePackageJsonModule(root) {
+		const packageJsonPath = join(root, "package.json");
+		try {
+			await access(packageJsonPath);
+		} catch (error) {
+			throw new AlephaError("No package.json found in project root. Run 'npx alepha init' to create one.");
+		}
+		const content = await readFile(packageJsonPath, "utf8");
+		const packageJson$1 = JSON.parse(content);
+		if (!packageJson$1.type || packageJson$1.type !== "module") {
+			packageJson$1.type = "module";
+			await writeFile(packageJsonPath, JSON.stringify(packageJson$1, null, 2));
+		}
+	}
+	/**
+	* Ensure tsconfig.json exists in the project.
+	*
+	* Creates a standard Alepha tsconfig.json if none exists.
+	*
+	* @param root - The root directory of the project
+	*/
+	async ensureTsConfig(root) {
+		const tsconfigPath = join(root, "tsconfig.json");
+		try {
+			await access(tsconfigPath);
+		} catch {
+			await writeFile(tsconfigPath, tsconfigJson);
+		}
+	}
+	/**
+	* Download Alepha starter project from GitHub.
+	*
+	* Downloads and extracts the apps/starter directory from the main Alepha repository.
+	*
+	* @param targetDir - The directory where the project should be extracted
+	* @throws {AlephaError} If the download fails
+	*/
+	async downloadSampleProject(targetDir) {
+		const response = await fetch("https://api.github.com/repos/feunard/alepha/tarball/main", { headers: { "User-Agent": "Alepha-CLI" } });
+		if (!response.ok) throw new AlephaError(`Failed to download: ${response.statusText}`);
+		await pipeline(Readable.fromWeb(response.body), tar.extract({
+			cwd: targetDir,
+			strip: 3,
+			filter: (path) => {
+				const parts = path.split("/");
+				return parts.length >= 3 && parts[1] === "apps" && parts[2] === "starter";
+			}
+		}));
+	}
+	/**
+	* Get the path to Biome configuration file.
+	*
+	* Looks for an existing biome.json in the project root, or creates one if it doesn't exist.
+	*
+	* @param maybePath - Optional custom path to biome config
+	* @returns Absolute path to the biome.json config file
+	*/
+	async getBiomeConfigPath(maybePath) {
+		const root = process.cwd();
+		if (maybePath) try {
+			const path = join(root, maybePath);
+			await access(path);
+			return path;
+		} catch {}
+		try {
+			const path = join(root, "biome.json");
+			await access(path);
+			return path;
+		} catch {
+			return await this.runner.writeConfigFile("biome.json", biomeJson);
+		}
+	}
+	/**
+	* Get the path to Vite configuration file.
+	*
+	* Looks for an existing vite.config.ts in the project root, or creates one if it doesn't exist.
+	*
+	* @param root - The root directory of the project (defaults to process.cwd())
+	* @param serverEntry - Optional path to the server entry file to include in the config
+	* @returns Absolute path to the vite.config.ts file
+	*/
+	async getViteConfigPath(root, serverEntry) {
+		try {
+			const viteConfigPath = join(root, "vite.config.ts");
+			await access(viteConfigPath);
+			return viteConfigPath;
+		} catch {
+			return this.runner.writeConfigFile("vite.config.ts", viteConfigTs(serverEntry));
+		}
+	}
+	/**
+	* Load Alepha instance from a server entry file.
+	*
+	* Dynamically imports the server entry file and extracts the Alepha instance.
+	* Skips the automatic start process.
+	*
+	* @param rootDir - The root directory of the project
+	* @param explicitEntry - Optional explicit path to the entry file
+	* @returns Object containing the Alepha instance and the entry file path
+	* @throws {AlephaError} If the Alepha instance cannot be found
+	*/
+	async loadAlephaFromServerEntryFile(rootDir, explicitEntry) {
+		process.env.ALEPHA_SKIP_START = "true";
+		const entry = await boot.getServerEntry(rootDir, explicitEntry);
+		const mod = await tsImport(entry, { parentURL: import.meta.url });
+		this.log.debug(`Load entry: ${entry}`);
+		if (mod.default instanceof Alepha) return {
+			alepha: mod.default,
+			entry
+		};
+		const g = global;
+		if (g.__alepha) return {
+			alepha: g.__alepha,
+			entry
+		};
+		throw new AlephaError(`Could not find Alepha instance in entry file: ${entry}`);
+	}
+	/**
+	* Get DrizzleKitProvider from an Alepha instance.
+	*
+	* Searches the Alepha registry for the DrizzleKitProvider instance.
+	*
+	* @param alepha - The Alepha instance to search
+	* @returns The DrizzleKitProvider instance
+	*/
+	getKitFromAlepha(alepha$1) {
+		return alepha$1["registry"].values().find((it) => it.instance.constructor.name === "DrizzleKitProvider")?.instance;
+	}
+	/**
+	* Generate JavaScript code for Drizzle entities export.
+	*
+	* Creates a temporary entities.js file that imports from the entry file
+	* and exports database models for Drizzle Kit to process.
+	*
+	* @param entry - Path to the server entry file
+	* @param provider - Name of the database provider
+	* @param models - Array of model names to export
+	* @returns JavaScript code as a string
+	*/
+	generateEntitiesJs(entry, provider, models = []) {
+		return `
+import "${entry}";
+import { DrizzleKitProvider, Repository } from "@alepha/orm";
+
+const alepha = globalThis.__alepha;
+const kit = alepha.inject(DrizzleKitProvider);
+const provider = alepha.services(Repository).find((it) => it.provider.name === "${provider}").provider;
+const models = kit.getModels(provider);
+
+${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
+
+`.trim();
+	}
+	/**
+	* Prepare Drizzle configuration files for a database provider.
+	*
+	* Creates temporary entities.js and drizzle.config.js files needed
+	* for Drizzle Kit commands to run properly.
+	*
+	* @param options - Configuration options including kit, provider info, and paths
+	* @returns Path to the generated drizzle.config.js file
+	*/
+	async prepareDrizzleConfig(options) {
+		const models = Object.keys(options.kit.getModels(options.provider));
+		const entitiesJs = this.generateEntitiesJs(options.entry, options.providerName, models);
+		const config = {
+			schema: await this.runner.writeConfigFile("entities.js", entitiesJs, options.rootDir),
+			out: `./migrations/${options.providerName}`,
+			dialect: options.dialect,
+			dbCredentials: { url: options.providerUrl }
+		};
+		if (options.providerName === "pglite") config.driver = "pglite";
+		const drizzleConfigJs = `export default ${JSON.stringify(config, null, 2)}`;
+		return await this.runner.writeConfigFile("drizzle.config.js", drizzleConfigJs, options.rootDir);
+	}
+	/**
+	* Run a drizzle-kit command for all database providers in an Alepha instance.
+	*
+	* Iterates through all repository providers, prepares Drizzle config for each,
+	* and executes the specified drizzle-kit command.
+	*
+	* @param options - Configuration including command to run, flags, and logging
+	*/
+	async runDrizzleKitCommand(options) {
+		const rootDir = options.root;
+		this.log.debug(`Using project root: ${rootDir}`);
+		const { alepha: alepha$1, entry } = await this.loadAlephaFromServerEntryFile(rootDir, options.args);
+		const kit = this.getKitFromAlepha(alepha$1);
+		const repositoryProvider = alepha$1.inject("RepositoryProvider");
+		const accepted = /* @__PURE__ */ new Set([]);
+		for (const descriptor of repositoryProvider.getRepositories()) {
+			const provider = descriptor.provider;
+			const providerName = provider.name;
+			const dialect = provider.dialect;
+			if (accepted.has(providerName)) continue;
+			accepted.add(providerName);
+			this.log.info("");
+			this.log.info(options.logMessage(providerName, dialect));
+			const drizzleConfigJsPath = await this.prepareDrizzleConfig({
+				kit,
+				provider,
+				providerName,
+				providerUrl: provider.url,
+				dialect,
+				entry,
+				rootDir
+			});
+			await this.runner.exec(`drizzle-kit ${options.command} --config=${drizzleConfigJsPath}`);
+		}
+	}
+};
+
 //#endregion
 //#region src/commands/BiomeCommands.ts
 var BiomeCommands = class {
 	log = $logger();
 	runner = $inject(ProcessRunner);
+	utils = $inject(ProjectUtils);
 	biomeFlags = t.object({ config: t.optional(t.text({ aliases: ["c"] })) });
 	format = $command({
 		name: "format",
 		description: "Format the codebase using Biome",
 		flags: this.biomeFlags,
 		handler: async ({ flags }) => {
-			const configPath = await this.configPath(flags.config);
+			const configPath = await this.utils.getBiomeConfigPath(flags.config);
 			await this.runner.exec(`biome format --fix --config-path=${configPath}`);
 		}
 	});
@@ -15131,57 +16646,21 @@ var BiomeCommands = class {
 		description: "Run linter across the codebase using Biome",
 		flags: this.biomeFlags,
 		handler: async ({ flags }) => {
-			const configPath = await this.configPath(flags.config);
+			const configPath = await this.utils.getBiomeConfigPath(flags.config);
 			await this.runner.exec(`biome check --formatter-enabled=false --fix --config-path=${configPath}`);
 		}
 	});
-	async configPath(maybePath) {
-		const root = process.cwd();
-		if (maybePath) try {
-			const path = join(root, maybePath);
-			await access(path);
-			return path;
-		} catch {}
-		try {
-			const path = join(root, "biome.json");
-			await access(path);
-			return path;
-		} catch {
-			return await this.runner.writeConfigFile("biome.json", biomeJson);
-		}
-	}
 };
 
-//#endregion
-//#region src/assets/tsconfigJson.ts
-const tsconfigJson = `
-{
-  "compilerOptions": {
-    "module": "nodenext",
-    "target": "esnext",
-    "strict": true,
-    "jsx": "react-jsx",
-    "verbatimModuleSyntax": true,
-    "isolatedModules": true,
-    "moduleDetection": "force",
-    "skipLibCheck": true,
-    "resolveJsonModule": true,
-    "allowImportingTsExtensions": true
-  },
-  "exclude": ["node_modules", "dist"]
-}
-`.trim();
-
-//#endregion
-//#region src/version.ts
-const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
-const version = packageJson.version;
-
 //#endregion
 //#region src/commands/CoreCommands.ts
 var CoreCommands = class {
 	log = $logger();
 	cli = $inject(CliProvider);
+	utils = $inject(ProjectUtils);
+	/**
+	* Called when no command is provided
+	*/
 	root = $command({
 		root: true,
 		flags: t.object({ version: t.optional(t.boolean({
@@ -15196,6 +16675,9 @@ var CoreCommands = class {
 			this.cli.printHelp();
 		}
 	});
+	/**
+	* Create a new Alepha project based on one of the sample projects (for now, only one sample project is available)
+	*/
 	create = $command({
 		name: "create",
 		description: "Create a new Alepha project",
@@ -15206,9 +16688,9 @@ var CoreCommands = class {
 			pnpm: t.optional(t.boolean({ description: "Use pnpm package manager" }))
 		}),
 		summary: false,
-		handler: async ({ run: run$1, args, flags }) => {
+		handler: async ({ run: run$1, args, flags, root }) => {
 			const name = args;
-			const dest = join(process.cwd(), name);
+			const dest = join(root, name);
 			try {
 				await access(dest);
 				this.log.error(`Directory "${name}" already exists. Please choose a different project name.`);
@@ -15224,9 +16706,9 @@ var CoreCommands = class {
 				execCmd = "pnpm";
 			}
 			await mkdir(dest, { recursive: true }).catch(() => null);
-			await run$1("Downloading sample project", () => this.downloadSampleProject(dest));
+			await run$1("Downloading sample project", () => this.utils.downloadSampleProject(dest));
 			if (flags.yarn) {
-				await this.ensureYarn(dest);
+				await this.utils.ensureYarn(dest);
 				await run$1(`cd ${name} && yarn set version stable`, { alias: "Setting Yarn to stable version" });
 			}
 			await run$1(`cd ${name} && ${installCmd}`, { alias: "Installing dependencies" });
@@ -15239,6 +16721,9 @@ var CoreCommands = class {
 			this.log.info("");
 		}
 	});
+	/**
+	* Clean the project, removing the "dist" directory
+	*/
 	clean = $command({
 		name: "clean",
 		description: "Clean the project",
@@ -15246,104 +16731,30 @@ var CoreCommands = class {
 			await run$1.rm("./dist");
 		}
 	});
+	/**
+	* Ensure the project has the necessary Alepha configuration files.
+	* Add the correct dependencies to package.json and install them.
+	*/
 	init = $command({
 		name: "init",
 		description: "Add missing Alepha configuration files to the project",
 		flags: t.object({
-			yarn: t.boolean({ description: "Use Yarn package manager" }),
-			api: t.boolean({ description: "Include Alepha Server dependencies" }),
-			react: t.boolean({ description: "Include Alepha React dependencies" })
+			yarn: t.optional(t.boolean({ description: "Use Yarn package manager" })),
+			api: t.optional(t.boolean({ description: "Include Alepha Server dependencies" })),
+			react: t.optional(t.boolean({ description: "Include Alepha React dependencies" })),
+			orm: t.optional(t.boolean({ description: "Include Alepha ORM dependencies" }))
 		}),
-		handler: async ({ run: run$1, flags }) => {
-			const root = process.cwd();
-			await this.ensureTsConfig(root);
-			await this.ensurePackageJson(root, flags);
-			if (flags.yarn) await this.ensureYarn(root);
-			else await run$1("npm install", { alias: "Installing dependencies with npm" });
+		handler: async ({ run: run$1, flags, root }) => {
+			await run$1("Ensuring Alepha configuration files", async () => {
+				await this.utils.ensureTsConfig(root);
+				await this.utils.ensurePackageJson(root, flags);
+			});
+			if (flags.yarn) {
+				await this.utils.ensureYarn(root);
+				await run$1("yarn install", { alias: "Installing dependencies with Yarn" });
+			} else await run$1("npm install", { alias: "Installing dependencies with npm" });
 		}
 	});
-	async ensureYarn(root) {
-		const tsconfigPath = join(root, ".yarnrc.yml");
-		try {
-			await access(tsconfigPath);
-		} catch {
-			await writeFile(tsconfigPath, "nodeLinker: node-modules");
-		}
-	}
-	generatePackageJsonContent(modes) {
-		const dependencies = {
-			"@alepha/core": `^${version}`,
-			"@alepha/logger": `^${version}`,
-			"@alepha/datetime": `^${version}`
-		};
-		const devDependencies = {
-			alepha: `^${version}`,
-			"@alepha/vite": `^${version}`
-		};
-		if (modes.api) {
-			dependencies["@alepha/server"] = `^${version}`;
-			dependencies["@alepha/server-swagger"] = `^${version}`;
-			dependencies["@alepha/server-multipart"] = `^${version}`;
-		}
-		if (modes.react) {
-			dependencies["@alepha/server"] = `^${version}`;
-			dependencies["@alepha/server-links"] = `^${version}`;
-			dependencies["@alepha/react"] = `^${version}`;
-			dependencies.react = "^19.2.0";
-			devDependencies["@types/react"] = "^19.0.0";
-		}
-		return {
-			dependencies,
-			devDependencies,
-			scripts: {
-				dev: "alepha dev",
-				build: "alepha build"
-			}
-		};
-	}
-	async ensurePackageJson(root, modes) {
-		const packageJsonPath = join(root, "package.json");
-		try {
-			await access(packageJsonPath);
-		} catch (error) {
-			this.log.info("No package.json found. Creating one...");
-			await writeFile(packageJsonPath, JSON.stringify(this.generatePackageJsonContent(modes), null, 2));
-			return;
-		}
-		const content = await readFile(packageJsonPath, "utf8");
-		const packageJson$1 = JSON.parse(content);
-		if (!packageJson$1.type || packageJson$1.type !== "module") packageJson$1.type = "module";
-		const newPackageJson = this.generatePackageJsonContent(modes);
-		packageJson$1.type = "module";
-		packageJson$1.dependencies ??= {};
-		packageJson$1.devDependencies ??= {};
-		packageJson$1.scripts ??= {};
-		Object.assign(packageJson$1.dependencies, newPackageJson.dependencies);
-		Object.assign(packageJson$1.devDependencies, newPackageJson.devDependencies);
-		Object.assign(packageJson$1.scripts, newPackageJson.scripts);
-		await writeFile(packageJsonPath, JSON.stringify(packageJson$1, null, 2));
-	}
-	async ensureTsConfig(root = process.cwd()) {
-		const tsconfigPath = join(root, "tsconfig.json");
-		try {
-			await access(tsconfigPath);
-		} catch {
-			this.log.info("Missing tsconfig.json detected. Creating one...");
-			await writeFile(tsconfigPath, tsconfigJson);
-		}
-	}
-	async downloadSampleProject(targetDir) {
-		const response = await fetch("https://api.github.com/repos/feunard/alepha/tarball/main", { headers: { "User-Agent": "Alepha-CLI" } });
-		if (!response.ok) throw new AlephaError(`Failed to download: ${response.statusText}`);
-		await pipeline(Readable.fromWeb(response.body), tar.extract({
-			cwd: targetDir,
-			strip: 3,
-			filter: (path) => {
-				const parts = path.split("/");
-				return parts.length >= 3 && parts[1] === "apps" && parts[2] === "starter";
-			}
-		}));
-	}
 };
 
 //#endregion
@@ -15351,10 +16762,7 @@ var CoreCommands = class {
 var DrizzleCommands = class {
 	log = $logger();
 	runner = $inject(ProcessRunner);
-	flags = t.object({ root: t.text({
-		description: "Project root",
-		default: "."
-	}) });
+	utils = $inject(ProjectUtils);
 	/**
 	* Check if database migrations are up to date
 	*
@@ -15368,15 +16776,14 @@ var DrizzleCommands = class {
 	check = $command({
 		name: "db:check-migrations",
 		description: "Verify database migration files are up to date",
-		flags: this.flags,
 		args: t.optional(t.text({
 			title: "path",
 			description: "Path to the Alepha server entry file"
 		})),
-		handler: async ({ flags, args }) => {
-			const rootDir = join(process.cwd(), flags.root);
+		handler: async ({ args, root }) => {
+			const rootDir = root;
 			this.log.debug(`Using project root: ${rootDir}`);
-			const { alepha: alepha$1 } = await this.loadAlephaFromServerEntryFile(rootDir, args);
+			const { alepha: alepha$1 } = await this.utils.loadAlephaFromServerEntryFile(rootDir, args);
 			const models = [];
 			const repositories = alepha$1.descriptors("repository");
 			const kit = createRequire(import.meta.url)("drizzle-kit/api");
@@ -15429,14 +16836,13 @@ var DrizzleCommands = class {
 		name: "db:generate",
 		description: "Generate migration files based on current database schema",
 		summary: false,
-		flags: this.flags,
 		args: t.optional(t.text({
 			title: "path",
 			description: "Path to the Alepha server entry file"
 		})),
-		handler: async ({ flags, args }) => {
-			await this.runDrizzleKitCommand({
-				flags,
+		handler: async ({ args, root }) => {
+			await this.utils.runDrizzleKitCommand({
+				root,
 				args,
 				command: "generate",
 				logMessage: (providerName, dialect) => `Generate '${providerName}' migrations (${dialect}) ...`
@@ -15455,14 +16861,13 @@ var DrizzleCommands = class {
 		name: "db:push",
 		description: "Push database schema changes directly to the database",
 		summary: false,
-		flags: this.flags,
 		args: t.optional(t.text({
 			title: "path",
 			description: "Path to the Alepha server entry file"
 		})),
-		handler: async ({ flags, args }) => {
-			await this.runDrizzleKitCommand({
-				flags,
+		handler: async ({ root, args }) => {
+			await this.utils.runDrizzleKitCommand({
+				root,
 				args,
 				command: "push",
 				logMessage: (providerName, dialect) => `Push '${providerName}' schema (${dialect}) ...`
@@ -15481,14 +16886,13 @@ var DrizzleCommands = class {
 		name: "db:migrate",
 		description: "Apply pending database migrations",
 		summary: false,
-		flags: this.flags,
 		args: t.optional(t.text({
 			title: "path",
 			description: "Path to the Alepha server entry file"
 		})),
-		handler: async ({ flags, args }) => {
-			await this.runDrizzleKitCommand({
-				flags,
+		handler: async ({ root, args }) => {
+			await this.utils.runDrizzleKitCommand({
+				root,
 				args,
 				command: "migrate",
 				logMessage: (providerName, dialect) => `Migrate '${providerName}' database (${dialect}) ...`
@@ -15507,108 +16911,25 @@ var DrizzleCommands = class {
 		name: "db:studio",
 		description: "Launch Drizzle Studio database browser",
 		summary: false,
-		flags: this.flags,
 		args: t.optional(t.text({
 			title: "path",
 			description: "Path to the Alepha server entry file"
 		})),
-		handler: async ({ flags, args }) => {
-			await this.runDrizzleKitCommand({
-				flags,
+		handler: async ({ root, args }) => {
+			await this.utils.runDrizzleKitCommand({
+				root,
 				args,
 				command: "studio",
 				logMessage: (providerName, dialect) => `Launch Studio for '${providerName}' (${dialect}) ...`
 			});
 		}
 	});
-	/**
-	* Run a drizzle-kit command for all database providers
-	*/
-	async runDrizzleKitCommand(options) {
-		const rootDir = join(process.cwd(), options.flags.root);
-		this.log.debug(`Using project root: ${rootDir}`);
-		const { alepha: alepha$1, entry } = await this.loadAlephaFromServerEntryFile(rootDir, options.args);
-		const kit = this.getKitFromAlepha(alepha$1);
-		const repositoryProvider = alepha$1.inject("RepositoryProvider");
-		const accepted = /* @__PURE__ */ new Set([]);
-		for (const descriptor of repositoryProvider.getRepositories()) {
-			const provider = descriptor.provider;
-			const providerName = provider.name;
-			const dialect = provider.dialect;
-			if (accepted.has(providerName)) continue;
-			accepted.add(providerName);
-			this.log.info("");
-			this.log.info(options.logMessage(providerName, dialect));
-			const drizzleConfigJsPath = await this.prepareDrizzleConfig({
-				kit,
-				provider,
-				providerName,
-				providerUrl: provider.url,
-				dialect,
-				entry,
-				rootDir
-			});
-			await this.runner.exec(`drizzle-kit ${options.command} --config=${drizzleConfigJsPath}`);
-		}
-	}
-	/**
-	* Prepare Drizzle configuration files for a provider
-	*/
-	async prepareDrizzleConfig(options) {
-		const models = Object.keys(options.kit.getModels(options.provider));
-		const entitiesJs = this.generateEntitiesJs(options.entry, options.providerName, models);
-		const config = {
-			schema: await this.runner.writeConfigFile("entities.js", entitiesJs, options.rootDir),
-			out: `./migrations/${options.providerName}`,
-			dialect: options.dialect,
-			dbCredentials: { url: options.providerUrl }
-		};
-		if (options.providerName === "pglite") config.driver = "pglite";
-		const drizzleConfigJs = "export default " + JSON.stringify(config, null, 2);
-		return await this.runner.writeConfigFile("drizzle.config.js", drizzleConfigJs, options.rootDir);
-	}
-	/**
-	* Get DrizzleKitProvider from Alepha instance
-	*/
-	getKitFromAlepha(alepha$1) {
-		return alepha$1["registry"].values().find((it) => it.instance.constructor.name === "DrizzleKitProvider")?.instance;
-	}
-	async loadAlephaFromServerEntryFile(rootDir, explicitEntry) {
-		process.env.ALEPHA_SKIP_START = "true";
-		const entry = await boot.getServerEntry(rootDir, explicitEntry);
-		const mod = await tsImport(entry, { parentURL: import.meta.url });
-		this.log.debug(`Load entry: ${entry}`);
-		if (mod.default instanceof Alepha) return {
-			alepha: mod.default,
-			entry
-		};
-		const g = global;
-		if (g.__alepha) return {
-			alepha: g.__alepha,
-			entry
-		};
-		throw new AlephaError(`Could not find Alepha instance in entry file: ${entry}`);
-	}
-	generateEntitiesJs(entry, provider, models = []) {
-		return `
-import "${entry}";
-import { DrizzleKitProvider, Repository } from "@alepha/postgres";
-
-const alepha = globalThis.__alepha;
-const kit = alepha.inject(DrizzleKitProvider);
-const provider = alepha.services(Repository).find((it) => it.provider.name === "${provider}").provider;
-const models = kit.getModels(provider);
-
-${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
-
-`.trim();
-	}
 };
 
 //#endregion
 //#region src/commands/VerifyCommands.ts
 var VerifyCommands = class {
-	runner = $inject(ProcessRunner);
+	processRunner = $inject(ProcessRunner);
 	/**
 	* Run a series of verification commands to ensure code quality and correctness.
 	*
@@ -15641,32 +16962,17 @@ var VerifyCommands = class {
 		name: "typecheck",
 		description: "Check TypeScript types across the codebase",
 		handler: async () => {
-			await this.runner.exec("tsc --noEmit");
+			await this.processRunner.exec("tsc --noEmit");
 		}
 	});
 };
 
-//#endregion
-//#region src/assets/viteConfigTs.ts
-const viteConfigTs = (serverEntry) => `
-import { viteAlepha } from "@alepha/vite";
-
-export default {
-  plugins: [
-    viteAlepha(${serverEntry ? `{ serverEntry: "${serverEntry}" }` : ""}),
-  ],
-  test: {
-    globals: true,
-  },
-};
-`.trim();
-
 //#endregion
 //#region src/commands/ViteCommands.ts
 var ViteCommands = class {
 	log = $logger();
 	runner = $inject(ProcessRunner);
-	core = $inject(CoreCommands);
+	utils = $inject(ProjectUtils);
 	run = $command({
 		name: "run",
 		description: "Run a TypeScript file directly",
@@ -15679,8 +16985,8 @@ var ViteCommands = class {
 			title: "path",
 			description: "Filepath to run"
 		}),
-		handler: async ({ args, flags }) => {
-			await this.core.ensureTsConfig();
+		handler: async ({ args, flags, root }) => {
+			await this.utils.ensureTsConfig(root);
 			await this.runner.exec(`tsx ${flags.watch ? "watch " : ""}${args}`);
 		}
 	});
@@ -15697,18 +17003,19 @@ var ViteCommands = class {
 			title: "path",
 			description: "Filepath to run"
 		})),
-		handler: async ({ args }) => {
-			const root = process.cwd();
-			await this.core.ensureTsConfig(root);
-			await this.ensurePackageJson(root);
+		handler: async ({ args, root }) => {
+			await this.utils.ensureTsConfig(root);
+			await this.utils.ensurePackageJsonModule(root);
 			const entry = await boot.getServerEntry(root, args);
 			this.log.trace("Entry file found", { entry });
 			try {
 				await access(join(root, "index.html"));
 			} catch {
 				this.log.trace("No index.html found, running entry file with tsx");
+				await this.runner.exec(`tsx watch ${entry}`);
+				return;
 			}
-			const configPath = await this.configPath(root, args ? entry : void 0);
+			const configPath = await this.utils.getViteConfigPath(root, args ? entry : void 0);
 			this.log.trace("Vite config found", { configPath });
 			await this.runner.exec(`vite -c=${configPath}`);
 		}
@@ -15729,15 +17036,15 @@ var ViteCommands = class {
 		}),
 		handler: async ({ flags, args }) => {
 			const root = process.cwd();
-			await this.core.ensureTsConfig(root);
-			await this.ensurePackageJson(root);
+			await this.utils.ensureTsConfig(root);
+			await this.utils.ensurePackageJsonModule(root);
 			const entry = await boot.getServerEntry(root, args);
 			this.log.trace("Entry file found", { entry });
 			await rm("dist", {
 				recursive: true,
 				force: true
 			});
-			const configPath = await this.configPath(root, args ? entry : void 0);
+			const configPath = await this.utils.getViteConfigPath(root, args ? entry : void 0);
 			const env = {};
 			if (flags.stats) env.ALEPHA_BUILD_STATS = "true";
 			await this.runner.exec(`vite build -c=${configPath}`, env);
@@ -15746,35 +17053,12 @@ var ViteCommands = class {
 	test = $command({
 		name: "test",
 		description: "Run tests using Vitest",
-		handler: async () => {
-			await this.core.ensureTsConfig();
-			const configPath = await this.configPath();
+		handler: async ({ root }) => {
+			await this.utils.ensureTsConfig(root);
+			const configPath = await this.utils.getViteConfigPath(root);
 			await this.runner.exec(`vitest run -c=${configPath}`);
 		}
 	});
-	async configPath(root = process.cwd(), serverEntry) {
-		try {
-			const viteConfigPath = join(root, "vite.config.ts");
-			await access(viteConfigPath);
-			return viteConfigPath;
-		} catch {
-			return this.runner.writeConfigFile("vite.config.ts", viteConfigTs(serverEntry));
-		}
-	}
-	async ensurePackageJson(root = process.cwd()) {
-		const packageJsonPath = join(root, "package.json");
-		try {
-			await access(packageJsonPath);
-		} catch (error) {
-			throw new AlephaError("No package.json found in project root. Run 'npx alepha init' to create one.");
-		}
-		const content = await readFile(packageJsonPath, "utf8");
-		const packageJson$1 = JSON.parse(content);
-		if (!packageJson$1.type || packageJson$1.type !== "module") {
-			packageJson$1.type = "module";
-			await writeFile(packageJsonPath, JSON.stringify(packageJson$1, null, 2));
-		}
-	}
 };
 
 //#endregion