silgi 0.42.5 → 0.43.0

package/dist/cli/config/types.mjs

@@ -0,0 +1,147 @@
+import { dirname, isAbsolute, join, relative, resolve } from "pathe";
+import { isPresents, relativeWithDot, resolveSilgiModule } from "silgi/kit";
+import { existsSync, lstatSync, promises } from "node:fs";
+import { readPackageJSON } from "pkg-types";
+import { withTrailingSlash } from "ufo";
+import { defu } from "defu";
+
+//#region src/cli/config/types.ts
+function getDirectory(p) {
+	try {
+		return isAbsolute(p) && lstatSync(p).isFile() ? dirname(p) : p;
+	} catch {}
+	return p;
+}
+function renderAttrs(obj) {
+	const attrs = [];
+	for (const key in obj) attrs.push(renderAttr(key, obj[key]));
+	return attrs.join(" ");
+}
+function renderAttr(key, value) {
+	return value ? `${key}="${value}"` : "";
+}
+async function silgiGenerateType(silgi) {
+	const rootDirWithSlash = withTrailingSlash(silgi.options.rootDir);
+	const tsConfigPath = resolve(silgi.options.rootDir, silgi.options.typescript.tsconfigPath);
+	const tsconfigDir = dirname(tsConfigPath);
+	const include = new Set([
+		relativeWithDot(tsconfigDir, join(silgi.options.build.typesDir, "silgi-config.d.ts")).replace(/^(?=[^.])/, "./"),
+		join(relativeWithDot(tsconfigDir, silgi.options.rootDir), "**/*"),
+		...silgi.options.srcDir === silgi.options.rootDir ? [] : [join(relativeWithDot(tsconfigDir, silgi.options.srcDir), "**/*")]
+	]);
+	const exclude = new Set([relativeWithDot(tsconfigDir, "node_modules"), relativeWithDot(tsconfigDir, "dist")]);
+	for (const dir of silgi.options.modulesDir) exclude.add(relativeWithDot(silgi.options.build.dir, dir));
+	const moduleEntryPaths = [];
+	for (const m of silgi.scanModules) if (m.entryPath) moduleEntryPaths.push(getDirectory(m.entryPath));
+	const modulePaths = await resolveSilgiModule(rootDirWithSlash, moduleEntryPaths);
+	for (const path of modulePaths) {
+		const relative$1 = relativeWithDot(tsconfigDir, path);
+		include.add(join(relative$1, "runtime"));
+		exclude.add(join(relative$1, "runtime/server"));
+		include.add(join(relative$1, "dist/runtime"));
+		exclude.add(join(relative$1, "dist/runtime/server"));
+	}
+	let tsConfig = silgi.options.typescript?.tsConfig || {};
+	const defaultConfig = defu(tsConfig, {
+		compilerOptions: {
+			esModuleInterop: true,
+			allowSyntheticDefaultImports: true,
+			skipLibCheck: true,
+			allowImportingTsExtensions: true,
+			target: "ESNext",
+			allowJs: true,
+			resolveJsonModule: true,
+			moduleDetection: "force",
+			isolatedModules: true,
+			verbatimModuleSyntax: true,
+			strict: true,
+			noUncheckedIndexedAccess: true,
+			noImplicitOverride: true,
+			forceConsistentCasingInFileNames: true,
+			noEmit: true,
+			module: "Preserve",
+			moduleResolution: "bundler",
+			useDefineForClassFields: true,
+			noImplicitThis: true,
+			jsx: "preserve",
+			customConditions: silgi.options.typescript.customConditions,
+			paths: {}
+		},
+		include: [...include],
+		exclude: [...exclude]
+	});
+	tsConfig = defaultConfig;
+	if (isPresents(["hono"])) tsConfig = defu(defaultConfig, { compilerOptions: {
+		jsx: "react-jsx",
+		jsxImportSource: "hono/jsx"
+	} });
+	if (isPresents(["npm-package"])) tsConfig = defu(tsConfig, {
+		compilerOptions: {
+			target: "es2022",
+			lib: [
+				"es2022",
+				"webworker",
+				"dom.iterable"
+			],
+			moduleDetection: "force",
+			module: "preserve",
+			paths: {},
+			resolveJsonModule: true,
+			allowJs: true,
+			strict: true,
+			noImplicitOverride: true,
+			noEmit: true,
+			allowSyntheticDefaultImports: true,
+			esModuleInterop: false,
+			forceConsistentCasingInFileNames: true,
+			isolatedModules: true,
+			verbatimModuleSyntax: true,
+			skipLibCheck: true
+		},
+		include: [...include],
+		exclude: [...exclude]
+	});
+	tsConfig.compilerOptions ||= {};
+	tsConfig.compilerOptions.paths ||= {};
+	tsConfig.include ||= [];
+	for (const alias in tsConfig.compilerOptions.paths) {
+		const paths = tsConfig.compilerOptions.paths[alias];
+		tsConfig.compilerOptions.paths[alias] = await Promise.all(paths.map(async (path) => {
+			if (!isAbsolute(path)) return path;
+			const stats = await promises.stat(path).catch(() => null);
+			return relativeWithDot(tsconfigDir, stats?.isFile() ? path.replace(/\b\.\w+$/g, "") : path);
+		}));
+	}
+	const references = [];
+	await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
+		if (typeof id !== "string") return;
+		if (id === "./src" && silgi.options.preset === "npm-package") id = resolve(silgi.options.rootDir);
+		const pkg = await readPackageJSON(id, { url: silgi.options.rootDir }).catch(() => null);
+		references.push({ types: pkg?.name || id });
+	}));
+	const declarations = [];
+	await silgi.callHook("prepare:types", {
+		references,
+		declarations,
+		tsConfig
+	});
+	tsConfig.include = [...new Set(tsConfig.include.map((p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p))];
+	tsConfig.exclude = [...new Set(tsConfig.exclude.map((p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p))];
+	const _declarations = [
+		...references.map((ref) => {
+			if ("path" in ref && isAbsolute(ref.path)) ref.path = relative(silgi.options.build.dir, ref.path);
+			return `/// <reference ${renderAttrs(ref)} />`;
+		}),
+		...declarations,
+		"",
+		"export {}",
+		""
+	];
+	return {
+		declarations: _declarations,
+		tsConfig
+	};
+}
+
+//#endregion
+export { silgiGenerateType };

package/dist/cli/core/apiful.mjs

@@ -0,0 +1,36 @@
+import { consola as consola$1 } from "consola";
+import { join, resolve } from "pathe";
+import { addTemplate, hasSilgiModule } from "silgi/kit";
+import { generateDTS } from "apiful/openapi";
+
+//#region src/cli/core/apiful.ts
+async function generateApiFul(silgi) {
+	const config = silgi.options.apiFul;
+	if (!hasSilgiModule("openapi")) {
+		silgi.options.dev || silgi.logger.info("Silgi OpenAPI module not found, if you want to use it, please install it @silgi/openapi");
+		return;
+	}
+	if (!config.services || hasSilgiModule("openapi")) {
+		config.services ??= {};
+		config.services = { silgi: { schema: join(silgi.options.build.dir, "openapi.json") } };
+	}
+	const resolvedOpenAPIServices = Object.fromEntries(Object.entries(config?.services ?? {}).filter(([, service]) => Boolean(service.schema)));
+	if (Object.keys(resolvedOpenAPIServices).length === 0) {
+		consola$1.info("No OpenAPI schemas found, skipping generation");
+		return;
+	}
+	for (const service of Object.values(resolvedOpenAPIServices)) if (typeof service.schema === "string" && !service.schema.startsWith("http")) service.schema = resolve(silgi.options.rootDir, service.schema);
+	const types = await generateDTS(resolvedOpenAPIServices);
+	silgi.hook("prepare:types", (opts) => {
+		opts.references.push({ path: "./apiful.d.ts" });
+	});
+	addTemplate({
+		filename: "types/apiful.d.ts",
+		where: ".silgi",
+		write: true,
+		getContents: () => types
+	});
+}
+
+//#endregion
+export { generateApiFul };

package/dist/cli/core/app.mjs

@@ -0,0 +1,105 @@
+import { pluginsDeclaration, templates_exports } from "./templates.mjs";
+import { dirname, resolve } from "pathe";
+import { normalizeTemplate, useLogger } from "silgi/kit";
+import { existsSync, mkdirSync, promises, writeFileSync } from "node:fs";
+
+//#region src/cli/core/app.ts
+const postTemplates = [pluginsDeclaration.filename];
+const logger = useLogger("silgi");
+async function generateApp(app, options = {}) {
+	app.templates = Object.values(templates_exports).concat(app.options.build.templates);
+	await app.callHook("app:templates", app);
+	app.templates = app.templates.map((tmpl) => {
+		let dir;
+		switch (tmpl.where) {
+			case ".silgi":
+				dir = app.options.build.dir;
+				break;
+			case "server":
+				dir = app.options.silgi.serverDir;
+				break;
+			case "client":
+				dir = app.options.silgi.clientDir;
+				break;
+			case "root":
+				dir = app.options.rootDir;
+				break;
+			default: dir = app.options.silgi.vfsDir;
+		}
+		return normalizeTemplate(tmpl, dir);
+	});
+	const filteredTemplates = {
+		pre: [],
+		post: []
+	};
+	for (const template of app.templates) {
+		if (template.watch === false) {
+			if (Array.isArray(app.options.watchOptions.ignored)) app.options.watchOptions.ignored.push(`${template.dst || template.src}`);
+		}
+		if (options.filter && !options.filter(template)) continue;
+		const key = template.filename && postTemplates.includes(template.filename) ? "post" : "pre";
+		filteredTemplates[key].push(template);
+	}
+	const templateContext = { app };
+	const writes = [];
+	const dirs = new Set();
+	const changedTemplates = [];
+	async function processTemplate(template) {
+		let dir;
+		switch (template.where) {
+			case ".silgi":
+				dir = app.options.build.dir;
+				break;
+			case "server":
+				dir = app.options.silgi.serverDir;
+				break;
+			case "client":
+				dir = app.options.silgi.clientDir;
+				break;
+			case "root":
+				dir = app.options.rootDir;
+				break;
+			default: dir = app.options.silgi.vfsDir;
+		}
+		const fullPath = template.dst || resolve(dir, template.filename);
+		const start = performance.now();
+		const contents = await compileTemplate(template, templateContext).catch((e) => {
+			logger.error(`Could not compile template \`${template.filename}\`.`);
+			logger.error(e);
+			throw e;
+		});
+		template.modified = true;
+		if (template.modified) changedTemplates.push(template);
+		const perf = performance.now() - start;
+		const setupTime = Math.round(perf * 100) / 100;
+		if (app.options.debug || setupTime > 500) logger.info(`Compiled \`${template.filename}\` in ${setupTime}ms`);
+		if (template.modified && template.write) {
+			dirs.add(dirname(fullPath));
+			if (template.skipIfExists && existsSync(fullPath)) return;
+			writes.push(() => writeFileSync(fullPath, contents, "utf8"));
+		}
+	}
+	await Promise.allSettled(filteredTemplates.pre.map(processTemplate));
+	await Promise.allSettled(filteredTemplates.post.map(processTemplate));
+	for (const dir of dirs) mkdirSync(dir, { recursive: true });
+	for (const write of writes) if (!app.errors.length) write();
+	if (changedTemplates.length) await app.callHook("app:templatesGenerated", app, changedTemplates, options);
+}
+/** @internal */
+async function compileTemplate(template, ctx) {
+	delete ctx.utils;
+	if (template.src) try {
+		return await promises.readFile(template.src, "utf-8");
+	} catch (err) {
+		logger.error(`[nuxt] Error reading template from \`${template.src}\``);
+		throw err;
+	}
+	if (template.getContents) return template.getContents({
+		...ctx,
+		options: template.options
+	});
+	throw new Error(`[nuxt] Invalid template. Templates must have either \`src\` or \`getContents\`: ${JSON.stringify(template)}`);
+}
+
+//#endregion
+export { generateApp };

package/dist/cli/core/devServer.mjs

@@ -0,0 +1,10 @@
+import { useSilgiCLI } from "silgi";
+
+//#region src/cli/core/devServer.ts
+async function reloadScan(path, _stats) {
+	const silgi = useSilgiCLI();
+	await silgi.callHook("reload:scan", path, _stats);
+}
+
+//#endregion
+export { reloadScan };

package/dist/cli/core/env.mjs

@@ -0,0 +1,68 @@
+import { resolve } from "pathe";
+import { existsSync, promises } from "node:fs";
+import * as dotenv from "dotenv";
+
+//#region src/cli/core/env.ts
+/**
+* Load and interpolate environment variables into `process.env`.
+* If you need more control (or access to the values), consider using `loadDotenv` instead
+*
+*/
+async function setupDotenv(options) {
+	const targetEnvironment = options.env ?? process.env;
+	const environment = await loadDotenv({
+		cwd: options.cwd,
+		fileName: options.fileName ?? ".env",
+		env: targetEnvironment,
+		interpolate: options.interpolate ?? true
+	});
+	for (const key in environment) if (!key.startsWith("_") && targetEnvironment[key] === void 0) targetEnvironment[key] = environment[key];
+	return environment;
+}
+/** Load environment variables into an object. */
+async function loadDotenv(options) {
+	const environment = Object.create(null);
+	const dotenvFile = resolve(options.cwd, options.fileName);
+	if (existsSync(dotenvFile)) {
+		const parsed = dotenv.parse(await promises.readFile(dotenvFile, "utf8"));
+		Object.assign(environment, parsed);
+	}
+	if (!options.env?._applied) {
+		Object.assign(environment, options.env);
+		environment._applied = true;
+	}
+	if (options.interpolate) interpolate(environment);
+	return environment;
+}
+function interpolate(target, source = {}, parse$1 = (v) => v) {
+	function getValue(key) {
+		return source[key] === void 0 ? target[key] : source[key];
+	}
+	function interpolate$1(value, parents = []) {
+		if (typeof value !== "string") return value;
+		const matches = value.match(/(.?\$\{?[\w:]*\}?)/g) || [];
+		return parse$1(matches.reduce((newValue, match) => {
+			const parts = /(.?)\$\{?([\w:]+)?\}?/.exec(match) || [];
+			const prefix = parts[1];
+			let value$1, replacePart;
+			if (prefix === "\\") {
+				replacePart = parts[0] || "";
+				value$1 = replacePart.replace(String.raw`\$`, "$");
+			} else {
+				const key = parts[2];
+				replacePart = (parts[0] || "").slice((prefix || "").length);
+				if (key && parents.includes(key)) {
+					console.warn(`Please avoid recursive environment variables ( loop: ${parents.join(" > ")} > ${key} )`);
+					return "";
+				}
+				value$1 = key ? getValue(key) : void 0;
+				value$1 = interpolate$1(value$1, key ? [...parents, key] : parents);
+			}
+			return value$1 === void 0 ? newValue : newValue.replace(replacePart, value$1);
+		}, value));
+	}
+	for (const key in target) target[key] = interpolate$1(getValue(key));
+}
+
+//#endregion
+export { setupDotenv };

package/dist/cli/core/installPackage.mjs

@@ -0,0 +1,60 @@
+import { useSilgiCLI } from "../../core/silgiApp.mjs";
+import { addNPMPackage, addTemplate } from "silgi/kit";
+
+//#region src/cli/core/installPackage.ts
+/**
+* Install packages for the Silgi CLI.
+*
+* @param silgi - The SilgiCLI instance.
+* @default
+*/
+async function installPackages(silgi = useSilgiCLI()) {
+	await addNPMPackage([{
+		name: "zod-to-json-schema",
+		isDev: false,
+		when: silgi.options.schemaVendor === "zod"
+	}, {
+		name: "@valibot/to-json-schema",
+		isDev: false,
+		when: silgi.options.schemaVendor === "valibot"
+	}]);
+	await addNPMPackage([
+		{
+			name: "@fastify/deepmerge",
+			isDev: false
+		},
+		{
+			name: "@silgi/ecosystem",
+			isDev: false
+		},
+		{
+			name: "unadapter",
+			isDev: false
+		},
+		{
+			name: "apiful",
+			isDev: false
+		}
+	]);
+	const packages = {
+		dependencies: { ...silgi.options.installPackages?.dependencies },
+		devDependencies: { ...silgi.options.installPackages?.devDependencies }
+	};
+	if (silgi.options.preset === "npm-package") {
+		packages.devDependencies = {
+			...packages.devDependencies,
+			...packages.dependencies
+		};
+		packages.dependencies = {};
+	}
+	if (silgi.options.debug === true || silgi.options.debug?.install) addTemplate({
+		filename: "install.json",
+		where: ".silgi",
+		write: true,
+		getContents: () => JSON.stringify(packages, null, 2)
+	});
+	return packages;
+}
+
+//#endregion
+export { installPackages };

package/dist/cli/core/runtimeConfig.mjs

@@ -0,0 +1,70 @@
+import { useSilgiCLI } from "silgi";
+import { addTemplate } from "silgi/kit";
+import { initRuntimeConfig } from "silgi/runtime";
+import { snakeCase } from "scule";
+
+//#region src/cli/core/runtimeConfig.ts
+function useCLIRuntimeConfig(silgi = useSilgiCLI()) {
+	const safeRuntimeConfig = JSON.parse(JSON.stringify(silgi.options.runtimeConfig));
+	silgi.hook("prepare:configs.ts", (data) => {
+		data.runtimeConfig = safeRuntimeConfig;
+		silgi.options.envOptions = silgi.options.envOptions;
+	});
+	addTemplate({
+		filename: "env.example",
+		write: true,
+		where: ".silgi",
+		getContents() {
+			const flattenedConfig = flattenObject(safeRuntimeConfig);
+			const groupedVars = {};
+			Object.entries(flattenedConfig).forEach(([key, { value, originalPath }]) => {
+				const shouldExclude = silgi.options.codegen.env.safeList.some((safePath) => {
+					if (safePath.length !== originalPath.length) return false;
+					return safePath.every((segment, index) => segment.toLowerCase() === originalPath[index]?.toLowerCase());
+				});
+				if (shouldExclude) return;
+				if (originalPath.length > 0) {
+					const firstKey = originalPath[0];
+					if (typeof firstKey === "string") {
+						const categoryName = extractCategoryFromCamel(firstKey);
+						if (!groupedVars[categoryName]) groupedVars[categoryName] = {};
+						groupedVars[categoryName][key] = value;
+					}
+				} else {
+					if (!groupedVars.OTHER) groupedVars.OTHER = {};
+					groupedVars.OTHER[key] = value;
+				}
+			});
+			return Object.entries(groupedVars).map(([category, vars]) => {
+				const varsContent = Object.entries(vars).map(([key, value]) => `${key}=${value}`).join("\n");
+				return `# ${category}\n${varsContent}`;
+			}).join("\n\n");
+		}
+	});
+	const _sharedRuntimeConfig = initRuntimeConfig(silgi.options.envOptions, silgi.options.runtimeConfig);
+	silgi.options.runtimeConfig = safeRuntimeConfig;
+	return _sharedRuntimeConfig;
+}
+function extractCategoryFromCamel(str) {
+	if (/^[a-z]+[A-Z]/.test(str)) {
+		const matches = str.match(/^([a-z]+)([A-Z][a-z0-9]*)?/);
+		if (matches && matches[1] && matches[2]) return `${matches[1].toUpperCase()}_${matches[2].toUpperCase()}`;
+	}
+	return str.toUpperCase();
+}
+function flattenObject(obj, prefix = "SILGI", originalPath = []) {
+	return Object.entries(obj).reduce((acc, [key, value]) => {
+		const formattedKey = snakeCase(key).toUpperCase();
+		const newKey = `${prefix}_${formattedKey}`;
+		const newPath = [...originalPath, key];
+		if (typeof value === "object" && value !== null) Object.assign(acc, flattenObject(value, newKey, newPath));
+		else acc[newKey] = {
+			value,
+			originalPath: newPath
+		};
+		return acc;
+	}, {});
+}
+
+//#endregion
+export { useCLIRuntimeConfig };

package/dist/cli/core/scan.mjs

@@ -0,0 +1,35 @@
+import { join, relative } from "pathe";
+import { glob } from "tinyglobby";
+
+//#region src/cli/core/scan.ts
+const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
+async function scanAndSyncOptions(silgi) {
+	const scannedModules = await scanModules(silgi);
+	silgi.options.modules = silgi.options.modules || [];
+	for (const modPath of scannedModules) if (!silgi.options.modules.includes(modPath)) silgi.options.modules.push(modPath);
+}
+async function scanModules(silgi) {
+	const files = await scanFiles(silgi, "silgi/modules");
+	return files.map((f) => f.fullPath);
+}
+async function scanFiles(silgi, name) {
+	const files = await Promise.all(silgi.options.scanDirs.map((dir) => scanDir(silgi, dir, name))).then((r) => r.flat());
+	return files;
+}
+async function scanDir(silgi, dir, name) {
+	const fileNames = await glob(join(name, GLOB_SCAN_PATTERN), {
+		cwd: dir,
+		dot: true,
+		ignore: silgi.options.ignore,
+		absolute: true
+	});
+	return fileNames.map((fullPath) => {
+		return {
+			fullPath,
+			path: relative(join(dir, name), fullPath)
+		};
+	}).sort((a, b) => a.path.localeCompare(b.path));
+}
+
+//#endregion
+export { scanAndSyncOptions };

package/dist/cli/core/silgi.mjs

@@ -0,0 +1,111 @@
+import { prepareEnv } from "../commands/env.mjs";
+import { loadOptions } from "../config/loader.mjs";
+import { frameworkSetup } from "../framework/index.mjs";
+import { registerModuleExportScan } from "../module/exportScan.mjs";
+import { installModules } from "../module/install.mjs";
+import { scanSilgiExports } from "../scan/scanExportFile.mjs";
+import { scanModules } from "../module/scan.mjs";
+import { prepareConfigs } from "../scan/prepareConfigs.mjs";
+import { prepareScanFile } from "../scan/prepareScanFile.mjs";
+import { readScanFile } from "../utils/readScanFile.mjs";
+import { createStorageCLI } from "../utils/storage.mjs";
+import { scanAndSyncOptions } from "./scan.mjs";
+import { consola as consola$1 } from "consola";
+import { join } from "pathe";
+import { autoImportTypes, silgiCLICtx } from "silgi";
+import { createDebugger, createHooks } from "hookable";
+import { resolveSilgiPath } from "silgi/kit";
+import { sharedRuntimeConfig, useRuntimeConfig } from "silgi/runtime";
+import { runtimeDir } from "silgi/runtime/meta";
+import { createUnimport } from "unimport";
+
+//#region src/cli/core/silgi.ts
+async function createSilgiCLI(config = {}, opts = {}) {
+	const options = await loadOptions(config, opts);
+	await prepareEnv(options);
+	const hooks = createHooks();
+	const silgi = {
+		services: {},
+		middleware: [],
+		shareds: {},
+		schemas: {},
+		resolvers: [],
+		unimport: void 0,
+		options,
+		hooks,
+		errors: [],
+		_requiredModules: {},
+		logger: opts.consola || consola$1.withTag("silgi"),
+		close: () => silgi.hooks.callHook("close", silgi),
+		storage: void 0,
+		scanModules: [],
+		templates: [],
+		callHook: hooks.callHook,
+		addHooks: hooks.addHooks,
+		hook: hooks.hook,
+		adapters: {},
+		useLocalConfig: () => useRuntimeConfig(void 0, options.runtimeConfig),
+		meta: {}
+	};
+	if (silgiCLICtx.tryUse()) {
+		silgiCLICtx.unset();
+		silgiCLICtx.set(silgi);
+	} else {
+		silgiCLICtx.set(silgi);
+		silgi.hook("close", () => silgiCLICtx.unset());
+	}
+	if (silgi.options.debug) {
+		createDebugger(silgi.hooks, { tag: "silgi" });
+		silgi.options.plugins.push({
+			path: join(runtimeDir, "internal/debug"),
+			packageImport: "silgi/runtime/internal/debug"
+		});
+	}
+	await scanAndSyncOptions(silgi);
+	await scanSilgiExports();
+	await scanModules(silgi);
+	await installModules(silgi, true);
+	await prepareConfigs();
+	sharedRuntimeConfig(silgi.options.runtimeConfig, silgi.options.dev);
+	if (silgi.options.adapters && Object.keys(silgi.options.adapters)?.length > 0) for (const [key, value] of Object.entries(silgi.options.adapters)) if (typeof value === "function") {
+		const resolved = value(silgi);
+		silgi.adapters[key] = resolved instanceof Promise ? await resolved : resolved;
+	} else silgi.adapters[key] = value;
+	await prepareScanFile(silgi);
+	await readScanFile(silgi);
+	await installModules(silgi);
+	for (const framework of frameworkSetup) await framework(silgi);
+	silgi.storage = await createStorageCLI(silgi);
+	silgi.hooks.hook("close", async () => {
+		await silgi.storage.dispose();
+	});
+	if (silgi.options.logLevel !== void 0) silgi.logger.level = silgi.options.logLevel;
+	silgi.hooks.addHooks(silgi.options.hooks);
+	if (silgi.options.imports) {
+		silgi.options.imports.dirs ??= [];
+		silgi.options.imports.dirs = silgi.options.imports.dirs.map((dir) => {
+			if (typeof dir === "string") {
+				if (dir.startsWith("!")) return `!${resolveSilgiPath(dir.slice(1), options, silgi.options.rootDir)}`;
+				return resolveSilgiPath(dir, options, silgi.options.rootDir);
+			}
+			return dir;
+		});
+		silgi.options.imports.presets.push({
+			from: "silgi/types",
+			imports: autoImportTypes.map((type) => type),
+			type: true
+		});
+		silgi.options.imports.presets.push({
+			from: "silgi/runtime/internal/ofetch",
+			imports: ["createSilgiFetch", "silgi$fetch"]
+		});
+		silgi.unimport = createUnimport(silgi.options.imports);
+		await silgi.unimport.init();
+	}
+	await registerModuleExportScan(silgi);
+	await silgi.hooks.callHook("ready", silgi);
+	return silgi;
+}
+
+//#endregion
+export { createSilgiCLI };

package/dist/cli/core/templates.mjs

@@ -0,0 +1,38 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+
+//#region src/cli/core/templates.ts
+var templates_exports = {};
+__export(templates_exports, {
+	pluginsDeclaration: () => pluginsDeclaration,
+	vueShim: () => vueShim
+});
+const vueShim = {
+	filename: "delete/testtest.d.ts",
+	where: ".silgi",
+	getContents: ({ app }) => {
+		if (!app.options.typescript.shim) return "";
+		return [
+			"declare module '*.vue' {",
+			"  import { DefineComponent } from 'vue'",
+			"  const component: DefineComponent<{}, {}, any>",
+			"  export default component",
+			"}"
+		].join("\n");
+	}
+};
+const pluginsDeclaration = {
+	filename: "delete/testtest1.d.ts",
+	where: ".silgi",
+	getContents: async () => {
+		return `
+      declare module 'nuxt' {
+        interface NuxtApp {
+          $myPlugin: any;
+        }
+      }
+    `;
+	}
+};
+
+//#endregion
+export { pluginsDeclaration, templates_exports };