silgi 0.43.17 → 0.43.19

package/dist/build.d.mts

@@ -1,3 +1,3 @@
-import { watchDev } from "./cli/build/dev.mjs";
-import { prepareBuild } from "./cli/build/prepare.mjs";
+import { watchDev$1 as watchDev } from "./cli/build/dev.mjs";
+import { prepareBuild$1 as prepareBuild } from "./cli/build/prepare.mjs";
 export { prepareBuild, watchDev };

package/dist/cli/build/dev.d.mts

@@ -1,9 +1,10 @@
 import { FSWatcher } from "chokidar";
 
 //#region src/cli/build/dev.d.ts
-declare function watchDev(): Promise<{
+interface WatchDevResult {
   watcher: FSWatcher | undefined;
   close: () => Promise<void>;
-}>;
+}
+declare function watchDev(): Promise<WatchDevResult>;
 //#endregion
-export { watchDev };
+export { watchDev as watchDev$1 };

package/dist/cli/build/dev.mjs

@@ -8,46 +8,27 @@ import { basename } from "pathe";
 import { debounce } from "perfect-debounce";
 
 //#region src/cli/build/dev.ts
+const WATCH_IGNORE_FILES = [
+	"scan",
+	"meta",
+	"core",
+	"configs"
+];
+const WATCH_IGNORE_EXTENSIONS = [
+	"ts",
+	"js",
+	"mjs",
+	"cjs",
+	"d.ts",
+	"d.mts",
+	"d.cts",
+	"d.js"
+];
 const IGNORED_WATCH_PATTERNS = [
 	"**/.silgi/**",
 	"**/.output/**",
 	"**/types/**",
-	"**/scan.ts",
-	"**/scan.js",
-	"**/scan.mjs",
-	"**/scan.cjs",
-	"**/scan.d.ts",
-	"**/scan.d.mts",
-	"**/scan.d.cts",
-	"**/scan.d.js",
-	"**/scan.d.ts",
-	"**/meta.ts",
-	"**/meta.js",
-	"**/meta.mjs",
-	"**/meta.cjs",
-	"**/meta.d.ts",
-	"**/meta.d.mts",
-	"**/meta.d.cts",
-	"**/meta.d.js",
-	"**/meta.d.ts",
-	"**/core.ts",
-	"**/core.js",
-	"**/core.mjs",
-	"**/core.cjs",
-	"**/core.d.ts",
-	"**/core.d.mts",
-	"**/core.d.cts",
-	"**/core.d.js",
-	"**/core.d.ts",
-	"**/configs.ts",
-	"**/configs.js",
-	"**/configs.mjs",
-	"**/configs.cjs",
-	"**/configs.d.ts",
-	"**/configs.d.mts",
-	"**/configs.d.cts",
-	"**/configs.d.js",
-	"**/configs.d.ts"
+	...WATCH_IGNORE_FILES.flatMap((file) => WATCH_IGNORE_EXTENSIONS.map((ext) => `**/${file}.${ext}`))
 ];
 function isIgnoredByPattern(path) {
 	return IGNORED_WATCH_PATTERNS.some((pattern) => micromatch.isMatch(path, pattern));
@@ -55,14 +36,24 @@ function isIgnoredByPattern(path) {
 async function watchDev() {
 	const silgi = useSilgiCLI();
 	let watcher;
+	const changedFiles = new Set();
 	async function load() {
+		const startTime = performance.now();
+		if (changedFiles.size > 0) {
+			const fileList = Array.from(changedFiles).map((f) => basename(f)).join(", ");
+			consola.info(`Rebuilding: ${fileList}`);
+			changedFiles.clear();
+		}
 		await prepareBuild({
 			commandType: "prepare",
 			activeEnvironment: silgi.options.activeEnvironment || ".env",
 			dev: true
 		});
+		const endTime = performance.now();
+		const elapsedTime = Math.round(endTime - startTime);
+		silgi.logger.success(`Build completed in ${elapsedTime}ms`);
 	}
-	const reload = debounce(load);
+	const reload = debounce(load, 300);
 	const watchReloadEvents = new Set([
 		"add",
 		"addDir",
@@ -72,22 +63,17 @@ async function watchDev() {
 	]);
 	if (silgi.options.devServer.watch.length > 0) {
 		silgi.options.devServer.watch = [...new Set(silgi.options.devServer.watch)].filter((p) => !isIgnoredByPattern(p));
-		consola.info("[silgi] Watching files/directories:", silgi.options.devServer.watch);
+		consola.info(`[silgi] Watching ${silgi.options.devServer.watch.length} paths for changes`);
 		watcher = watch(silgi.options.devServer.watch, silgi.options.watchOptions);
 		watcher.on("all", async (event, path, stats) => {
 			if (!watchReloadEvents.has(event)) return;
-			const startTime = performance.now();
-			silgi.errors = [];
+			changedFiles.add(path);
 			try {
 				await reloadScan(path, stats);
 				await reload();
 			} catch (error) {
 				consola.withTag("silgi").error(error);
 			}
-			silgi.errors = [];
-			const endTime = performance.now();
-			const elapsedTime = Math.round(endTime - startTime);
-			silgi.logger.success(`${basename(path)} - ${elapsedTime}ms`);
 		}).on("error", (error) => {
 			consola.withTag("silgi").error(error);
 		});

package/dist/cli/build/prepare.d.mts

@@ -3,4 +3,4 @@ import { SilgiCLI, SilgiCLIConfig } from "silgi/types";
 //#region src/cli/build/prepare.d.ts
 declare function prepareBuild(config?: SilgiCLIConfig): Promise<SilgiCLI>;
 //#endregion
-export { prepareBuild };
+export { prepareBuild as prepareBuild$1 };

package/dist/cli/commands/init.mjs

@@ -45,7 +45,7 @@ const command = defineCommand({
 			"",
 			"export default defineSilgiConfig({",
 			`  preset: '${framework}',`,
-			`  compatibilityDate: '${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}',`,
+			`  compatibilityDate: '${new Date().toISOString().split("T")[0]}',`,
 			"",
 			"})",
 			""

package/dist/cli/commands/run.mjs

@@ -1,74 +1,28 @@
-import { watchDev } from "../build/dev.mjs";
-import { commonArgs } from "../utils/common.mjs";
-import prepare_default from "./prepare.mjs";
+import watch_default from "./watch.mjs";
 import consola from "consola";
 import { version } from "silgi/meta";
 import { runCommand } from "citty";
-import { execa } from "execa";
 
 //#region src/cli/commands/run.ts
 const command = {
 	meta: {
-		name: "dev",
-		description: "Start the development server for the project",
+		name: "run",
+		description: "Run a command with silgi watch (shortcut for \"silgi watch npm run <command>\")",
 		version
 	},
-	args: {
-		...commonArgs,
-		command: {
-			type: "string",
-			description: "your application start command",
-			required: false
-		}
-	},
+	args: { command: {
+		type: "string",
+		description: "your application start command",
+		required: false
+	} },
 	async run({ args, rawArgs }) {
-		await runCommand(prepare_default, { rawArgs: [
-			"--commandType",
-			"dev",
-			"--dev",
-			"true"
-		] });
-		const startCommand = args.command || rawArgs[0];
-		let childProcess = null;
-		let watcher = null;
-		let exiting = false;
-		const cleanupAndExit = async (code = 0) => {
-			if (exiting) return;
-			exiting = true;
-			try {
-				if (watcher?.close) await watcher.close().catch(() => {});
-				if (childProcess) childProcess.kill("SIGTERM");
-			} catch {}
-			process.exit(code);
-		};
-		const handleSignal = (signal) => {
-			consola.info(`Received ${signal}, terminating...`);
-			cleanupAndExit(0);
-		};
-		process.on("SIGINT", handleSignal);
-		process.on("SIGTERM", handleSignal);
-		process.on("SIGHUP", handleSignal);
-		try {
-			watcher = await watchDev();
-			consola.info(`Starting: nr ${startCommand}`);
-			childProcess = execa("nr", [startCommand], {
-				stdio: "inherit",
-				cwd: process.cwd()
-			});
-			childProcess.on("exit", (code) => {
-				if (code !== 0) consola.error(`Process exited with code ${code}`);
-				else consola.success("Process exited successfully.");
-				cleanupAndExit(code ?? 0);
-			});
-			childProcess.on("error", (err) => {
-				consola.error("Child process error:", err);
-				cleanupAndExit(1);
-			});
-			await childProcess;
-		} catch (error) {
-			consola.error("Error:", error);
-			cleanupAndExit(1);
+		const command$1 = args.command || rawArgs[0];
+		if (command$1 && !command$1.includes(" ")) {
+			const fullCommand = `npm run ${command$1}`;
+			consola.info(`Running: ${fullCommand}`);
+			return runCommand(watch_default, { rawArgs: [fullCommand] });
 		}
+		return runCommand(watch_default, { rawArgs });
 	}
 };
 var run_default = command;

package/dist/cli/commands/watch.mjs

@@ -1,11 +1,52 @@
 import { watchDev } from "../build/dev.mjs";
 import { commonArgs } from "../utils/common.mjs";
 import prepare_default from "./prepare.mjs";
+import { aggressiveCleanup, killPortProcesses, killProcessTree } from "../utils/processManager.mjs";
 import consola from "consola";
 import { version } from "silgi/meta";
 import { defineCommand, runCommand } from "citty";
+import { spawn } from "node:child_process";
 
 //#region src/cli/commands/watch.ts
+const runningProcesses = new Map();
+const openPorts = new Set();
+let watchHandle = null;
+let isShuttingDown = false;
+const isWindows = process.platform === "win32";
+function detectPort(data) {
+	const patterns = [
+		/localhost:(\d+)/i,
+		/127\.0\.0\.1:(\d+)/,
+		/0\.0\.0\.0:(\d+)/,
+		/\[::1\]:(\d+)/,
+		/Local:\s*http:\/\/[^:]+:(\d+)/i,
+		/➜\s+Local:\s+http:\/\/[^:]+:(\d+)/i
+	];
+	for (const pattern of patterns) {
+		const match = data.match(pattern);
+		if (match && match[1]) return Number.parseInt(match[1], 10);
+	}
+	return null;
+}
+async function shutdown() {
+	if (isShuttingDown) return;
+	isShuttingDown = true;
+	consola.info("\n🛑 Shutting down...");
+	for (const [pid, proc] of runningProcesses) if (!proc.killed) {
+		consola.info(`Terminating process ${pid}...`);
+		await killProcessTree(pid);
+	}
+	runningProcesses.clear();
+	for (const port of openPorts) await killPortProcesses(port);
+	openPorts.clear();
+	if (openPorts.size > 0 || runningProcesses.size > 0) {
+		consola.warn("Some processes may still be running, performing aggressive cleanup...");
+		await aggressiveCleanup();
+	}
+	if (watchHandle?.close) await watchHandle.close();
+	consola.success("✅ Shutdown complete\n");
+	process.exit(0);
+}
 const command = defineCommand({
 	meta: {
 		name: "dev",
@@ -21,27 +62,91 @@ const command = defineCommand({
 		stub: {
 			type: "boolean",
 			description: "Run in silgi development mode"
+		},
+		command: {
+			type: "string",
+			description: "Optional command to run alongside watch (e.g., \"npm run dev\")",
+			required: false
 		}
 	},
-	async run() {
+	async run({ args, rawArgs }) {
 		await runCommand(prepare_default, { rawArgs: [
 			"--commandType",
 			"dev",
 			"--dev",
 			"true"
 		] });
-		const watch = await watchDev();
-		process.on("SIGINT", async () => {
-			consola.withTag("silgi").info("Shutting down...");
-			if (watch) watch.close();
-			await watch.close();
-			process.exit(0);
-		});
+		watchHandle = await watchDev();
+		const userCommand = args.command || rawArgs[0];
+		if (userCommand) {
+			consola.withTag("silgi").info(`Starting: ${userCommand}`);
+			const [cmd, ...cmdArgs] = userCommand.split(" ");
+			if (!cmd) {
+				consola.error("Invalid command provided");
+				process.exit(1);
+			}
+			const childProcess = spawn(cmd, cmdArgs, {
+				stdio: [
+					"inherit",
+					"pipe",
+					"pipe"
+				],
+				cwd: process.cwd(),
+				shell: isWindows,
+				detached: !isWindows,
+				env: { ...process.env }
+			});
+			if (childProcess.pid) {
+				runningProcesses.set(childProcess.pid, childProcess);
+				consola.debug(`Started process ${childProcess.pid}`);
+			}
+			childProcess.stdout?.on("data", (data) => {
+				const output = data.toString();
+				process.stdout.write(output);
+				const port = detectPort(output);
+				if (port && !openPorts.has(port)) {
+					openPorts.add(port);
+					consola.info(`Detected server on port ${port}`);
+				}
+			});
+			childProcess.stderr?.on("data", (data) => {
+				process.stderr.write(data);
+			});
+			childProcess.on("exit", (code, signal) => {
+				if (childProcess.pid) runningProcesses.delete(childProcess.pid);
+				if (!isShuttingDown) {
+					if (code !== null && code !== 0) consola.error(`Process exited with code ${code}`);
+					else if (signal) consola.error(`Process killed by signal ${signal}`);
+					process.exit(code ?? 1);
+				}
+			});
+			childProcess.on("error", (err) => {
+				consola.error("Child process error:", err);
+				if (!isShuttingDown) process.exit(1);
+			});
+		}
 		consola.withTag("silgi").success("Prepare completed");
 		consola.withTag("silgi").info("Process is still running. Press Ctrl+C to exit.");
-		setInterval(() => {}, 1e3);
+		await new Promise(() => {});
 	}
 });
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+process.on("SIGHUP", shutdown);
+process.on("SIGQUIT", shutdown);
+process.on("exit", () => {
+	if (!isShuttingDown) for (const [pid] of runningProcesses) try {
+		process.kill(pid, "SIGKILL");
+	} catch {}
+});
+process.on("uncaughtException", (err) => {
+	consola.error("Uncaught exception:", err);
+	shutdown();
+});
+process.on("unhandledRejection", (err) => {
+	consola.error("Unhandled rejection:", err);
+	shutdown();
+});
 var watch_default = command;
 
 //#endregion

package/dist/cli/config/index.d.mts

@@ -1,3 +1,3 @@
-import { loadOptions } from "./loader.mjs";
-import { silgiGenerateType } from "./types.mjs";
+import { loadOptions$1 as loadOptions } from "./loader.mjs";
+import { silgiGenerateType$1 as silgiGenerateType } from "./types.mjs";
 export { loadOptions, silgiGenerateType };

package/dist/cli/config/loader.d.mts

@@ -3,4 +3,4 @@ import { LoadConfigOptions, SilgiCLIConfig, SilgiCLIOptions } from "silgi/types"
 //#region src/cli/config/loader.d.ts
 declare function loadOptions(configOverrides?: SilgiCLIConfig, opts?: LoadConfigOptions): Promise<SilgiCLIOptions>;
 //#endregion
-export { loadOptions };
+export { loadOptions as loadOptions$1 };

package/dist/cli/config/resolvers/compatibility.mjs

@@ -12,7 +12,7 @@ async function resolveCompatibilityOptions(options) {
 let _fallbackInfoShown = false;
 let _promptedUserToUpdate = false;
 async function _resolveDefault(options) {
-	const _todayDate = formatDate(/* @__PURE__ */ new Date());
+	const _todayDate = formatDate(new Date());
 	const consola$2 = consola.withTag("silgi");
 	consola$2.warn(`No valid compatibility date is specified.`);
 	const onFallback = () => {

package/dist/cli/config/types.d.mts

@@ -11,4 +11,4 @@ declare function silgiGenerateType(silgi: SilgiCLI): Promise<{
   tsConfig: TSConfig;
 }>;
 //#endregion
-export { silgiGenerateType };
+export { silgiGenerateType as silgiGenerateType$1 };

package/dist/cli/core/app.mjs

@@ -42,7 +42,7 @@ async function generateApp(app, options = {}) {
 	}
 	const templateContext = { app };
 	const writes = [];
-	const dirs = /* @__PURE__ */ new Set();
+	const dirs = new Set();
 	const changedTemplates = [];
 	async function processTemplate(template) {
 		let dir;

package/dist/cli/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import package_default from "../package.mjs";
+import { package_default } from "../package.mjs";
 import { defineCommand, runMain } from "citty";
 
 //#region src/cli/index.ts

package/dist/cli/module/install.mjs

@@ -1,4 +1,4 @@
-import { hasInstalledModule } from "../utils/compatibility.mjs";
+import { hasInstalledModule$1 as hasInstalledModule } from "../utils/compatibility.mjs";
 import { useSilgiCLI } from "silgi";
 import { createJiti } from "dev-jiti";
 

package/dist/cli/module/scan.mjs

@@ -103,12 +103,12 @@ async function scanModules(silgi) {
 	silgi.scanModules = modules;
 }
 function createDependencyGraph(modules) {
-	const graph = /* @__PURE__ */ new Map();
-	const inDegree = /* @__PURE__ */ new Map();
+	const graph = new Map();
+	const inDegree = new Map();
 	modules.forEach((module) => {
 		const key = module.meta?.configKey;
 		if (key) {
-			graph.set(key, /* @__PURE__ */ new Set());
+			graph.set(key, new Set());
 			inDegree.set(key, 0);
 		}
 	});
@@ -118,7 +118,7 @@ function createDependencyGraph(modules) {
 		const requiredDeps = module.meta?.requiredDependencies || [];
 		const beforeDeps = module.meta?.beforeDependencies || [];
 		const afterDeps = module.meta?.afterDependencies || [];
-		const processedDeps = /* @__PURE__ */ new Set();
+		const processedDeps = new Set();
 		requiredDeps.forEach((dep) => {
 			if (!graph.has(dep)) throw new Error(`Required dependency "${dep}" for module "${key}" is missing`);
 			graph.get(dep)?.add(key);
@@ -143,8 +143,8 @@ function createDependencyGraph(modules) {
 	};
 }
 function findCyclicDependencies(graph) {
-	const visited = /* @__PURE__ */ new Set();
-	const recursionStack = /* @__PURE__ */ new Set();
+	const visited = new Set();
+	const recursionStack = new Set();
 	const cycles = [];
 	function dfs(node, path = []) {
 		visited.add(node);

package/dist/cli/scan/prepareCommands.mjs

@@ -19,7 +19,7 @@ async function prepareCommands(silgi = useSilgiCLI()) {
 				if (command.tags) command.tags.forEach((tag) => acc.add(tag));
 			});
 			return acc;
-		}, /* @__PURE__ */ new Set());
+		}, new Set());
 		const data = [
 			genAugmentation("silgi/types", { SilgiCommands: { ...Object.fromEntries(Array.from(allTags.values()).map((tag) => [tag, "string"])) } }),
 			"",

package/dist/cli/scan/scanExportFile.mjs

@@ -152,7 +152,7 @@ async function extractExportEntitiesFromFile(absoluteFilePath, functionExportNam
 	const exportEntities = [];
 	const fileContent = await readFile(absoluteFilePath, "utf-8");
 	const parsed = await parseAsync(absoluteFilePath, fileContent);
-	const variableDeclarations = /* @__PURE__ */ new Map();
+	const variableDeclarations = new Map();
 	for (const node of parsed.program.body) {
 		if (node.type === "VariableDeclaration" && Array.isArray(node.declarations)) {
 			for (const decl of node.declarations) if (decl.type === "VariableDeclarator" && decl.id.type === "Identifier") variableDeclarations.set(decl.id.name, decl);
@@ -224,7 +224,7 @@ async function extractExportEntitiesFromFile(absoluteFilePath, functionExportNam
 	return exportEntities;
 }
 async function scanSilgiExports(path, packageName, silgiInstance = useSilgiCLI(), scanOptions = {}) {
-	const processedFilePaths = /* @__PURE__ */ new Set();
+	const processedFilePaths = new Set();
 	const alreadyScannedPaths = [];
 	const serverDirectory = path || silgiInstance.options.serverDir;
 	const functionExportNames = scanOptions.functionExportNames ?? DEFAULT_FUNCTION_EXPORT_NAMES;
@@ -263,7 +263,7 @@ async function scanSilgiExports(path, packageName, silgiInstance = useSilgiCLI()
 			if (!silgiInstance.options.extensions?.includes(fileExtension)) continue;
 			try {
 				const exportEntities = await extractExportEntitiesFromFile(absoluteFilePath, functionExportNames, interfaceExtendsNames);
-				const seenServiceSignatures = /* @__PURE__ */ new Map();
+				const seenServiceSignatures = new Map();
 				for (const entity of exportEntities) if ((entity.funcName === "createService" || entity.funcName === "createWebSocket") && entity.servicePath && entity.serviceMethod) {
 					const key = `${entity.serviceMethod}:${entity.servicePath}`;
 					if (seenServiceSignatures.has(key)) throw new Error(`Duplicate ${entity.funcName} detected for path "${entity.servicePath}" and method "${entity.serviceMethod}".\nFirst found in: ${seenServiceSignatures.get(key)}\nDuplicate in: ${absoluteFilePath}\nPlease ensure each service path/method combination is unique.`);

package/dist/cli/scan/writeTypesAndFiles.mjs

@@ -24,7 +24,7 @@ async function writeTypesAndFiles(silgi) {
 		await silgi.unimport.init();
 		const allImports = await silgi.unimport.getImports();
 		autoImportExports = toExports(allImports).replace(/#internal\/nitro/g, relative(typesDir, runtimeDir));
-		const resolvedImportPathMap = /* @__PURE__ */ new Map();
+		const resolvedImportPathMap = new Map();
 		for (const i of allImports.filter((i$1) => !i$1.type)) {
 			if (resolvedImportPathMap.has(i.from)) continue;
 			let path = resolveAlias$1(i.from, silgi.options.alias);

package/dist/cli/utils/compatibility.mjs

@@ -30,4 +30,4 @@ function hasInstalledModule(moduleKey, silgi = useSilgiCLI()) {
 }
 
 //#endregion
-export { checkSilgiCompatibility, hasInstalledModule };
+export { checkSilgiCompatibility, hasInstalledModule as hasInstalledModule$1 };