alepha 0.13.5 → 0.13.7

package/dist/cli/index.js

@@ -36,7 +36,7 @@ const biomeJson = `
   },
   "formatter": {
     "enabled": true,
-    "indentStyle": "space"
+    "useEditorconfig": true
   },
   "linter": {
     "enabled": true,
@@ -57,6 +57,32 @@ const biomeJson = `
 }
 `.trim();
 
+//#endregion
+//#region ../../src/cli/assets/dummySpecTs.ts
+const dummySpecTs = () => `
+import { test, expect } from "vitest";
+
+test("dummy test", () => {
+  expect(1 + 1).toBe(2);
+});
+`.trim();
+
+//#endregion
+//#region ../../src/cli/assets/editorconfig.ts
+const editorconfig = `
+# https://editorconfig.org
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2
+`.trim();
+
 //#endregion
 //#region ../../src/cli/assets/indexHtml.ts
 const indexHtml = (browserEntry) => `
@@ -86,6 +112,23 @@ alepha.with(AppRouter);
 run(alepha);
 `.trim();
 
+//#endregion
+//#region ../../src/cli/assets/mainTs.ts
+const mainTs = () => `
+import { Alepha, run } from "alepha";
+import { $logger } from "alepha/logger";
+
+const alepha = Alepha.create();
+
+alepha.with(() => {
+  const log = $logger();
+
+  log.info("Hello from Alepha!");
+});
+
+run(alepha);
+`.trim();
+
 //#endregion
 //#region ../../src/cli/assets/tsconfigJson.ts
 const tsconfigJson = `
@@ -132,34 +175,39 @@ var AlephaCliUtils = class {
 	/**
 	* Execute a command using npx with inherited stdio.
 	*
-	* @param command - The command to execute (will be passed to npx)
-	* @param env - Optional environment variables to set for the command
-	* @returns Promise that resolves when the process exits
-	*
 	* @example
 	* ```ts
 	* const runner = alepha.inject(ProcessRunner);
 	* await runner.exec("tsx watch src/index.ts");
 	* ```
 	*/
-	async exec(command, env = {}) {
+	async exec(command, options = {}) {
 		const root = process.cwd();
 		this.log.debug(`Executing command: ${command}`, { cwd: root });
+		const runExec = async (app$1, args$1) => {
+			const prog = spawn(app$1, args$1, {
+				stdio: "inherit",
+				cwd: root,
+				env: {
+					...process.env,
+					...options.env
+				}
+			});
+			await new Promise((resolve) => prog.on("exit", () => {
+				resolve();
+			}));
+		};
+		if (options.global) {
+			const [app$1, ...args$1] = command.split(" ");
+			await runExec(app$1, args$1);
+			return;
+		}
 		const suffix = process.platform === "win32" ? ".cmd" : "";
 		const [app, ...args] = command.split(" ");
-		const execPath = await this.checkFileExists(root, `node_modules/.bin/${app}${suffix}`, true);
+		let execPath = await this.checkFileExists(root, `node_modules/.bin/${app}${suffix}`, true);
+		if (!execPath) execPath = await this.checkFileExists(root, `node_modules/alepha/node_modules/.bin/${app}${suffix}`, true);
 		if (!execPath) throw new AlephaError(`Could not find executable for command '${app}'. Make sure the package is installed.`);
-		const prog = spawn(execPath, args, {
-			stdio: "inherit",
-			cwd: root,
-			env: {
-				...process.env,
-				...env
-			}
-		});
-		await new Promise((resolve) => prog.on("exit", () => {
-			resolve();
-		}));
+		await runExec(execPath, args);
 	}
 	/**
 	* Write a configuration file to node_modules/.alepha directory.
@@ -197,6 +245,24 @@ var AlephaCliUtils = class {
 		await this.fs.rm(join(root, "package-lock.json"), { force: true });
 		await this.fs.rm(join(root, "pnpm-lock.yaml"), { force: true });
 	}
+	async ensurePnpm(root) {
+		await this.fs.rm(join(root, "package-lock.json"), { force: true });
+		await this.fs.rm(join(root, "yarn.lock"), { force: true });
+		await this.fs.rm(join(root, ".yarn"), {
+			force: true,
+			recursive: true
+		});
+		await this.fs.rm(join(root, ".yarnrc.yml"), { force: true });
+	}
+	async ensureNpm(root) {
+		await this.fs.rm(join(root, "pnpm-lock.yaml"), { force: true });
+		await this.fs.rm(join(root, "yarn.lock"), { force: true });
+		await this.fs.rm(join(root, ".yarn"), {
+			force: true,
+			recursive: true
+		});
+		await this.fs.rm(join(root, ".yarnrc.yml"), { force: true });
+	}
 	/**
 	* Generate package.json content with Alepha dependencies.
 	*
@@ -265,6 +331,7 @@ var AlephaCliUtils = class {
 		if (opts.viteConfigTs) tasks.push(this.ensureViteConfig(root));
 		if (opts.indexHtml) tasks.push(this.ensureIndexHtml(root));
 		if (opts.biomeJson) tasks.push(this.ensureBiomeConfig(root));
+		if (opts.editorconfig) tasks.push(this.ensureEditorConfig(root));
 		await Promise.all(tasks);
 	}
 	/**
@@ -321,6 +388,16 @@ var AlephaCliUtils = class {
 		await this.ensureFileExists(root, "biome.json", biomeJson, true);
 	}
 	/**
+	* Ensure .editorconfig exists in the project.
+	*
+	* Creates a standard .editorconfig if none exists.
+	*
+	* @param root - The root directory of the project
+	*/
+	async ensureEditorConfig(root) {
+		await this.ensureFileExists(root, ".editorconfig", editorconfig, true);
+	}
+	/**
 	* Load Alepha instance from a server entry file.
 	*
 	* Dynamically imports the server entry file and extracts the Alepha instance.
@@ -454,10 +531,14 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 				rootDir
 			});
 			const flags = options.commandFlags ? ` ${options.commandFlags}` : "";
-			await this.exec(`drizzle-kit ${options.command} --config=${drizzleConfigJsPath}${flags}`, { NODE_OPTIONS: "--import tsx" });
+			await this.exec(`drizzle-kit ${options.command} --config=${drizzleConfigJsPath}${flags}`, { env: { NODE_OPTIONS: "--import tsx" } });
 		}
 	}
-	async getPackageManager(root) {
+	async getPackageManager(root, flags) {
+		if (flags?.yarn) return "yarn";
+		if (flags?.pnpm) return "pnpm";
+		if (flags?.npm) return "npm";
+		if (flags?.bun) return "bun";
 		if (await this.checkFileExists(root, "yarn.lock", true)) return "yarn";
 		if (await this.checkFileExists(root, "pnpm-lock.yaml", true)) return "pnpm";
 		return "npm";
@@ -478,10 +559,91 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 	async exists(root, dirName) {
 		return this.fs.exists(join(root, dirName));
 	}
+	/**
+	* Ensure src/main.ts exists with a minimal Alepha bootstrap.
+	*
+	* Creates the src directory and main.ts file if the src directory
+	* doesn't exist or is empty.
+	*
+	* @param root - The root directory of the project
+	*/
+	async ensureSrcMain(root) {
+		const srcDir = join(root, "src");
+		const mainPath = join(srcDir, "main.ts");
+		if (!await this.fs.exists(srcDir)) {
+			await this.fs.mkdir(srcDir, { recursive: true });
+			await this.fs.writeFile(mainPath, mainTs());
+			return;
+		}
+		if ((await this.fs.ls(srcDir)).length === 0) await this.fs.writeFile(mainPath, mainTs());
+	}
+	/**
+	* Ensure test directory exists with a dummy test file.
+	*
+	* Creates the test directory and a dummy.spec.ts file if the test directory
+	* doesn't exist or is empty.
+	*
+	* @param root - The root directory of the project
+	*/
+	async ensureTestDir(root) {
+		const testDir = join(root, "test");
+		const dummyPath = join(testDir, "dummy.spec.ts");
+		if (!await this.fs.exists(testDir)) {
+			await this.fs.mkdir(testDir, { recursive: true });
+			await this.fs.writeFile(dummyPath, dummySpecTs());
+			return;
+		}
+		if ((await this.fs.ls(testDir)).length === 0) await this.fs.writeFile(dummyPath, dummySpecTs());
+	}
 	async readPackageJson(root) {
 		const packageJson$1 = await this.fs.createFile({ path: join(root, "package.json") }).text();
 		return JSON.parse(packageJson$1);
 	}
+	/**
+	* Check if a dependency is installed in the project.
+	*
+	* @param root - The root directory of the project
+	* @param packageName - The name of the package to check
+	* @returns True if the package is in dependencies or devDependencies
+	*/
+	async hasDependency(root, packageName) {
+		try {
+			const pkg = await this.readPackageJson(root);
+			return !!(pkg.dependencies?.[packageName] || pkg.devDependencies?.[packageName]);
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Install a dependency if it's missing from the project.
+	*
+	* Automatically detects the package manager (yarn, pnpm, npm) and installs
+	* the package as a dev dependency if not already present.
+	*/
+	async ensureDependency(root, packageName, options = {}) {
+		const { dev = true } = options;
+		if (await this.hasDependency(root, packageName)) {
+			this.log.debug(`Dependency '${packageName}' is already installed`);
+			return;
+		}
+		const pm = await this.getPackageManager(root);
+		let cmd;
+		switch (pm) {
+			case "yarn":
+				cmd = `yarn add ${dev ? "-D" : ""} ${packageName}`;
+				break;
+			case "pnpm":
+				cmd = `pnpm add ${dev ? "-D" : ""} ${packageName}`;
+				break;
+			default: cmd = `npm install ${dev ? "--save-dev" : ""} ${packageName}`;
+		}
+		cmd = cmd.replace(/\s+/g, " ").trim();
+		if (options.run) await options.run(cmd, { alias: `installing ${packageName}` });
+		else {
+			this.log.debug(`Installing ${packageName}`);
+			await this.exec(cmd, { global: true });
+		}
+	}
 };
 
 //#endregion
@@ -494,6 +656,7 @@ var BiomeCommands = class {
 		description: "Format the codebase using Biome",
 		handler: async ({ root }) => {
 			await this.utils.ensureConfig(root, { biomeJson: true });
+			await this.utils.ensureDependency(root, "@biomejs/biome");
 			await this.utils.exec(`biome format --fix`);
 		}
 	});
@@ -502,6 +665,7 @@ var BiomeCommands = class {
 		description: "Run linter across the codebase using Biome",
 		handler: async ({ root }) => {
 			await this.utils.ensureConfig(root, { biomeJson: true });
+			await this.utils.ensureDependency(root, "@biomejs/biome");
 			await this.utils.exec(`biome check --formatter-enabled=false --fix`);
 		}
 	});
@@ -550,29 +714,39 @@ var CoreCommands = class {
 		flags: t.object({
 			yarn: t.optional(t.boolean({ description: "Use Yarn package manager" })),
 			pnpm: t.optional(t.boolean({ description: "Use pnpm package manager" })),
+			npm: t.optional(t.boolean({ description: "Use npm package manager" })),
+			bun: t.optional(t.boolean({ description: "Use Bun package manager" })),
 			react: t.optional(t.boolean({ description: "Include Alepha React dependencies" })),
-			ui: t.optional(t.boolean({ description: "Include Alepha UI dependencies" }))
+			ui: t.optional(t.boolean({ description: "Include Alepha UI dependencies" })),
+			test: t.optional(t.boolean({ description: "Include Vitest and create test directory" }))
 		}),
 		handler: async ({ run, flags, root }) => {
 			if (flags.ui) flags.react = true;
 			await run({
-				name: "Ensuring configuration files",
+				name: "ensuring configuration files",
 				handler: async () => {
 					await this.utils.ensureConfig(root, {
 						tsconfigJson: true,
 						packageJson: flags,
 						biomeJson: true,
 						viteConfigTs: true,
+						editorconfig: true,
 						indexHtml: !!flags.react
 					});
+					if (!flags.react) await this.utils.ensureSrcMain(root);
 				}
 			});
-			const guessedPm = await this.utils.getPackageManager(root);
-			if (flags.yarn || guessedPm === "yarn") {
+			const pm = await this.utils.getPackageManager(root, flags);
+			if (pm === "yarn") {
 				await this.utils.ensureYarn(root);
 				await run("yarn set version stable");
-				await run("yarn install", { alias: "Installing dependencies with Yarn" });
-			} else await run("npm install", { alias: "Installing dependencies with npm" });
+			} else if (pm === "pnpm") await this.utils.ensurePnpm(root);
+			else await this.utils.ensureNpm(root);
+			await run(`${pm} install`, { alias: `installing dependencies with ${pm}` });
+			if (flags.test) {
+				await this.utils.ensureTestDir(root);
+				await run(`${pm} ${pm === "yarn" ? "add" : "install"} -D vitest`, { alias: "setup testing with Vitest" });
+			}
 		}
 	});
 };
@@ -794,7 +968,8 @@ var VerifyCommands = class {
 	typecheck = $command({
 		name: "typecheck",
 		description: "Check TypeScript types across the codebase",
-		handler: async () => {
+		handler: async ({ root }) => {
+			await this.utils.ensureDependency(root, "typescript");
 			await this.utils.exec("tsc --noEmit");
 		}
 	});
@@ -853,6 +1028,7 @@ var ViteCommands = class {
 				await this.utils.exec(cmd);
 				return;
 			}
+			await this.utils.ensureDependency(root, "vite");
 			await this.utils.exec(`vite`);
 		}
 	});
@@ -881,6 +1057,7 @@ var ViteCommands = class {
 			this.log.trace("Entry file found", { entry });
 			const distDir = "dist";
 			const clientDir = "public";
+			await this.utils.ensureDependency(root, "vite", { run });
 			await run.rm("dist", { alias: "clean dist" });
 			const viteAlephaBuildOptions = (await import(join(root, "vite.config.ts")))?.default?.plugins.find((it) => !!it[OPTIONS])?.[OPTIONS] ?? {};
 			const stats = flags.stats ?? viteAlephaBuildOptions.stats ?? false;
@@ -979,12 +1156,7 @@ var ViteCommands = class {
 				tsconfigJson: true,
 				viteConfigTs: true
 			});
-			try {
-				await import("./dist-BlfFtOk2.js");
-			} catch {
-				this.log.error("Vitest is not installed. Please install it with `npm install -D vitest` or `yarn add -D vitest`.");
-				process.exit(1);
-			}
+			await this.utils.ensureDependency(root, "vitest");
 			await this.utils.exec(`vitest run ${this.env.VITEST_ARGS}`);
 		}
 	});