@ubean/cli 0.1.1 → 0.1.3

package/dist/page-Cmp7s9l2.js

@@ -0,0 +1,672 @@
+import { existsSync, promises } from "node:fs";
+import { dirname, extname, join, relative, resolve } from "node:path";
+import { consola } from "consola";
+//#region src/shared/fs-ops.ts
+function resolvePath(cwd, ...paths) {
+	return resolve(cwd, ...paths);
+}
+async function ensureDir(dir) {
+	await promises.mkdir(dir, { recursive: true });
+}
+async function exists(path) {
+	try {
+		await promises.access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function existsSync_(path) {
+	return existsSync(path);
+}
+async function readFile(path, encoding = "utf-8") {
+	return promises.readFile(path, encoding);
+}
+async function writeFile(path, content, encoding = "utf-8") {
+	await ensureDir(dirname(path));
+	await promises.writeFile(path, content, encoding);
+}
+async function appendFile(path, content, encoding = "utf-8") {
+	await promises.appendFile(path, content, encoding);
+}
+async function remove(path) {
+	await promises.rm(path, {
+		recursive: true,
+		force: true
+	});
+}
+async function copyFile(src, dest) {
+	await ensureDir(dirname(dest));
+	await promises.copyFile(src, dest);
+}
+async function copyDir(src, dest, options) {
+	await ensureDir(dest);
+	const entries = await promises.readdir(src, { withFileTypes: true });
+	for (const entry of entries) {
+		const srcPath = join(src, entry.name);
+		const destPath = join(dest, entry.name);
+		if (options?.filter && !options.filter(srcPath)) continue;
+		if (entry.isDirectory()) await copyDir(srcPath, destPath, options);
+		else await copyFile(srcPath, destPath);
+	}
+}
+async function readDir(path) {
+	return promises.readdir(path);
+}
+async function readJson(path) {
+	const content = await readFile(path);
+	return JSON.parse(content);
+}
+async function writeJson(path, data, indent = 2) {
+	await writeFile(path, `${JSON.stringify(data, null, indent)}\n`);
+}
+async function createBackup(path, options = {}) {
+	const backupPath = `${path}${options.backupSuffix || ".bak"}`;
+	if (!await exists(path)) return null;
+	await copyFile(path, backupPath);
+	if (options.removeOriginal) await remove(path);
+	return backupPath;
+}
+async function restoreBackup(path, options = {}) {
+	const backupPath = `${path}${options.backupSuffix || ".bak"}`;
+	if (!await exists(backupPath)) return false;
+	await copyFile(backupPath, path);
+	return true;
+}
+async function removeBackup(path, options = {}) {
+	await remove(`${path}${options.backupSuffix || ".bak"}`);
+}
+async function listFiles(dir, pattern) {
+	const results = [];
+	async function walk(current) {
+		const entries = await promises.readdir(current, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = join(current, entry.name);
+			if (entry.isDirectory()) {
+				if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".ubean") continue;
+				await walk(fullPath);
+			} else if (!pattern || pattern.test(entry.name)) results.push(fullPath);
+		}
+	}
+	if (await exists(dir)) await walk(dir);
+	return results;
+}
+function createFsOps(cwd) {
+	return {
+		cwd,
+		resolve: (...paths) => resolvePath(cwd, ...paths),
+		exists: (path) => exists(resolvePath(cwd, path)),
+		existsSync: (path) => existsSync_(resolvePath(cwd, path)),
+		readFile: (path, enc) => readFile(resolvePath(cwd, path), enc),
+		writeFile: (path, content, enc) => writeFile(resolvePath(cwd, path), content, enc),
+		appendFile: (path, content, enc) => appendFile(resolvePath(cwd, path), content, enc),
+		remove: (path) => remove(resolvePath(cwd, path)),
+		ensureDir: (path) => ensureDir(resolvePath(cwd, path)),
+		copyFile: (src, dest) => copyFile(resolvePath(cwd, src), resolvePath(cwd, dest)),
+		copyDir: (src, dest, opts) => copyDir(resolvePath(cwd, src), resolvePath(cwd, dest), opts),
+		readDir: (path) => readDir(resolvePath(cwd, path)),
+		readJson: (path) => readJson(resolvePath(cwd, path)),
+		writeJson: (path, data, indent) => writeJson(resolvePath(cwd, path), data, indent),
+		createBackup: (path, opts) => createBackup(resolvePath(cwd, path), opts),
+		restoreBackup: (path, opts) => restoreBackup(resolvePath(cwd, path), opts),
+		removeBackup: (path, opts) => removeBackup(resolvePath(cwd, path), opts),
+		listFiles: (dir, pattern) => listFiles(resolvePath(cwd, dir || "."), pattern),
+		relative: (to) => relative(cwd, resolve(cwd, to))
+	};
+}
+//#endregion
+//#region src/shared/templates.ts
+const DEFAULT_DELIMITERS = ["{{", "}}"];
+function renderTemplate(template, options = {}) {
+	const vars = options.variables || {};
+	const [open, close] = options.delimiters || DEFAULT_DELIMITERS;
+	const openEsc = open.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const closeEsc = close.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const pattern = new RegExp(`${openEsc}\\s*([\\w.]+)\\s*${closeEsc}`, "g");
+	return template.replace(pattern, (_match, key) => {
+		const value = getNestedValue(vars, key);
+		if (value === void 0 || value === null) return `${open}${key}${close}`;
+		return String(value);
+	});
+}
+function getNestedValue(obj, path) {
+	const parts = path.split(".");
+	let current = obj;
+	for (const part of parts) {
+		if (current == null || typeof current !== "object") return void 0;
+		current = current[part];
+	}
+	return current;
+}
+function toKebabCase(str) {
+	return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function toPascalCase(str) {
+	return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (c) => c.toUpperCase());
+}
+function toCamelCase(str) {
+	const pascal = toPascalCase(str);
+	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+const PAGE_TEMPLATE = `<script setup lang="ts">
+definePage({
+  meta: {
+    title: '{{name}}'
+  }
+});
+<\/script>
+
+<template>
+  <div class="{{kebabName}}-page">
+    <div>{{name}}</div>
+  </div>
+</template>
+
+`;
+const API_TEMPLATE = `import { defineHandler } from 'ubean';
+
+export default defineHandler(async c => {
+  return c.json({ message: '{{name}} endpoint' });
+});
+`;
+const MIDDLEWARE_TEMPLATE = `import { defineMiddleware } from 'ubean';
+
+export default defineMiddleware(async (c, next) => {
+  console.log('{{name}} middleware');
+  await next();
+});
+`;
+const LAYOUT_TEMPLATE = `<script setup lang="ts">
+definePage({
+  meta: {
+    title: '{{name}}'
+  }
+});
+<\/script>
+
+<template>
+  <div class="{{kebabName}}">
+    <slot />
+  </div>
+</template>
+`;
+const CRON_TEMPLATE = `import { defineScheduled } from 'ubean';
+
+export default defineScheduled({
+  name: '{{name}}',
+  schedule: '{{schedule}}'
+}, async () => {
+  console.log('Running {{name}} cron task');
+});
+`;
+const PLUGIN_TEMPLATE = `import { definePlugin } from 'ubean';
+
+export default definePlugin({
+  name: '{{kebabName}}',
+  setup() {
+    console.log('{{name}} plugin setup');
+  }
+});
+`;
+function renderPageTemplate(data) {
+	return renderTemplate(PAGE_TEMPLATE, { variables: {
+		...data,
+		kebabName: toKebabCase(data.name)
+	} });
+}
+function renderApiTemplate(data) {
+	return renderTemplate(API_TEMPLATE, { variables: {
+		...data,
+		kebabName: toKebabCase(data.name)
+	} });
+}
+function renderMiddlewareTemplate(data) {
+	return renderTemplate(MIDDLEWARE_TEMPLATE, { variables: data });
+}
+function renderLayoutTemplate(data) {
+	const kebabName = toKebabCase(data.name);
+	return renderTemplate(LAYOUT_TEMPLATE, { variables: {
+		...data,
+		kebabName,
+		pascalName: toPascalCase(data.name)
+	} });
+}
+function renderCronTemplate(data) {
+	return renderTemplate(CRON_TEMPLATE, { variables: {
+		...data,
+		kebabName: toKebabCase(data.name)
+	} });
+}
+function renderPluginTemplate(data) {
+	const kebabName = toKebabCase(data.name);
+	return renderTemplate(PLUGIN_TEMPLATE, { variables: {
+		...data,
+		kebabName,
+		pascalName: toPascalCase(data.name)
+	} });
+}
+//#endregion
+//#region src/page.ts
+const logger = consola.withTag("ubean-cli");
+function getSrcDir(cwd) {
+	return join(cwd, "src");
+}
+function getDirForType(cwd, type) {
+	const srcDir = getSrcDir(cwd);
+	switch (type) {
+		case "page":
+		case "reuse": return join(srcDir, "pages");
+		case "api": return join(srcDir, "routes");
+		case "layout": return join(srcDir, "layouts");
+		case "middleware": return join(srcDir, "middleware");
+		case "cron": return join(srcDir, "server", "crons");
+		case "plugin": return join(srcDir, "plugins");
+		default: return srcDir;
+	}
+}
+/** Resolve a baseDir that may be relative or absolute into an absolute path. */
+function resolveBaseDir(cwd, baseDir) {
+	return baseDir.startsWith("/") ? baseDir : join(cwd, baseDir);
+}
+function resolveTargetPath(baseDir, path, type) {
+	let normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+	if (normalizedPath === "" || normalizedPath === "/") normalizedPath = type === "page" || type === "reuse" ? "index" : "index";
+	if (type === "page" || type === "layout" || type === "reuse") {
+		if (type === "page" || type === "layout") {
+			if (normalizedPath.endsWith(".vue")) return join(baseDir, normalizedPath);
+			const ext = ".vue";
+			if (normalizedPath.endsWith("/") || normalizedPath === "") return join(baseDir, normalizedPath, `index${ext}`);
+			return join(baseDir, `${normalizedPath}${ext}`);
+		}
+		if (normalizedPath.endsWith(".reuse.ts")) return join(baseDir, normalizedPath);
+		if (normalizedPath.endsWith(".ts")) return join(baseDir, normalizedPath.replace(/\.ts$/, ".reuse.ts"));
+		const ext = ".reuse.ts";
+		if (normalizedPath.endsWith("/") || normalizedPath === "") return join(baseDir, normalizedPath, `index${ext}`);
+		return join(baseDir, `${normalizedPath}${ext}`);
+	}
+	if (normalizedPath.endsWith(".ts") || normalizedPath.endsWith(".js")) return join(baseDir, normalizedPath);
+	const ext = ".ts";
+	if (normalizedPath.endsWith("/") || normalizedPath === "") return join(baseDir, normalizedPath, `index${ext}`);
+	if ((type === "api" || type === "middleware" || type === "cron" || type === "plugin") && !normalizedPath.includes(".")) return join(baseDir, `${normalizedPath}${ext}`);
+	return join(baseDir, normalizedPath);
+}
+function sanitizeNameSegment(seg) {
+	return seg.replace(/^\[\.\.\.(.+)\]$/, "All$1").replace(/^\[\[(.+)\]\]$/, "$1Optional").replace(/^\[(.+)\]$/, "$1").replace(/[^a-zA-Z0-9$_]/g, "");
+}
+function extractNameFromPath(filePath, _type) {
+	const parts = filePath.split("/");
+	const basename = parts.pop() || "";
+	let nameWithoutExt = basename.replace(extname(basename), "");
+	if (nameWithoutExt.endsWith(".reuse")) nameWithoutExt = nameWithoutExt.slice(0, -6);
+	const segments = [];
+	for (const part of parts) {
+		const cleaned = sanitizeNameSegment(part);
+		if (cleaned) segments.push(toPascalCase(cleaned));
+	}
+	if (nameWithoutExt !== "index") segments.push(toPascalCase(sanitizeNameSegment(nameWithoutExt)));
+	else if (segments.length === 0) return "Index";
+	return segments.join("") || "Index";
+}
+function getTemplateContent(type, name, path, method, schedule) {
+	switch (type) {
+		case "page": return renderPageTemplate({
+			name,
+			path: `/${path.replace(/\.vue$/, "").replace(/\/index$/, "")}`,
+			kebabName: toKebabCase(name),
+			pascalName: name,
+			camelName: toCamelCase(name)
+		});
+		case "reuse": return `import { definePage } from 'ubean';
+
+export default definePage({
+  name: '${name}'
+});
+`;
+		case "api": return renderApiTemplate({
+			name,
+			method: method || "GET",
+			path: `/api/${path.replace(/\.ts$/, "").replace(/\/index$/, "")}`,
+			kebabName: toKebabCase(name)
+		});
+		case "layout": return renderLayoutTemplate({
+			name,
+			path: `/${path.replace(/\.vue$/, "").replace(/\/index$/, "")}`,
+			pascalName: toPascalCase(name)
+		});
+		case "middleware": return `import { defineMiddleware } from 'ubean';
+
+export default defineMiddleware(async (c, next) => {
+  console.log('${name} middleware');
+  await next();
+});
+`;
+		case "cron": return renderCronTemplate({
+			name,
+			schedule: schedule || "* * * * *",
+			kebabName: toKebabCase(name)
+		});
+		case "plugin": return renderPluginTemplate({
+			name,
+			kebabName: toKebabCase(name),
+			pascalName: toPascalCase(name)
+		});
+		default: return "";
+	}
+}
+async function scaffold(options) {
+	const cwd = options.cwd || process.cwd();
+	const fs = createFsOps(cwd);
+	const result = {
+		created: [],
+		deleted: [],
+		restored: [],
+		skipped: [],
+		errors: []
+	};
+	try {
+		const relativePath = resolveTargetPath(options.baseDir ? resolveBaseDir(cwd, options.baseDir) : getDirForType(cwd, options.type), options.path, options.type).replace(`${cwd}/`, "");
+		if (await fs.exists(relativePath)) {
+			if (!options.force) {
+				result.skipped.push(relativePath);
+				return result;
+			}
+			await fs.createBackup(relativePath);
+		}
+		if (options.dry) {
+			result.created.push(relativePath);
+			return result;
+		}
+		const name = extractNameFromPath(relativePath, options.type);
+		const content = getTemplateContent(options.type, name, options.path, options.method, options.schedule);
+		await fs.writeFile(relativePath, content);
+		result.created.push(relativePath);
+	} catch (err) {
+		result.errors.push(err instanceof Error ? err.message : String(err));
+	}
+	return result;
+}
+async function deleteScaffold(options) {
+	const cwd = options.cwd || process.cwd();
+	const fs = createFsOps(cwd);
+	const result = {
+		created: [],
+		deleted: [],
+		restored: [],
+		skipped: [],
+		errors: []
+	};
+	try {
+		const relativePath = resolveTargetPath(options.baseDir ? resolveBaseDir(cwd, options.baseDir) : getDirForType(cwd, options.type), options.path, options.type).replace(`${cwd}/`, "");
+		if (!await fs.exists(relativePath)) {
+			result.errors.push(`${relativePath} does not exist`);
+			return result;
+		}
+		if (options.dry) {
+			result.deleted.push(relativePath);
+			return result;
+		}
+		if (options.force) {
+			await fs.remove(relativePath);
+			result.deleted.push(relativePath);
+			return result;
+		}
+		await fs.createBackup(relativePath, { removeOriginal: true });
+		result.deleted.push(relativePath);
+	} catch (err) {
+		result.errors.push(err instanceof Error ? err.message : String(err));
+	}
+	return result;
+}
+async function recoverScaffold(options) {
+	const cwd = options.cwd || process.cwd();
+	const fs = createFsOps(cwd);
+	const result = {
+		created: [],
+		deleted: [],
+		restored: [],
+		skipped: [],
+		errors: []
+	};
+	try {
+		const relativePath = resolveTargetPath(options.baseDir ? resolveBaseDir(cwd, options.baseDir) : getDirForType(cwd, options.type), options.path, options.type).replace(`${cwd}/`, "");
+		if (options.dry) {
+			const backupPath = `${relativePath}.bak`;
+			if (await fs.exists(backupPath)) result.restored.push(relativePath);
+			else result.errors.push(`No backup found for ${relativePath}`);
+			return result;
+		}
+		if (await fs.restoreBackup(relativePath)) {
+			result.restored.push(relativePath);
+			await fs.removeBackup(relativePath);
+		} else result.errors.push(`No backup found for ${relativePath}`);
+	} catch (err) {
+		result.errors.push(err instanceof Error ? err.message : String(err));
+	}
+	return result;
+}
+async function listScaffoldableFiles(cwd, type, baseDir) {
+	const fs = createFsOps(cwd);
+	const relativeBase = (baseDir ? resolveBaseDir(cwd, baseDir) : getDirForType(cwd, type)).replace(`${cwd}/`, "");
+	return (await fs.listFiles(relativeBase)).map((f) => f.replace(`${cwd}/`, ""));
+}
+const scaffoldTypes = [
+	"page",
+	"api",
+	"layout",
+	"middleware",
+	"cron",
+	"plugin"
+];
+const allTypes = [
+	"page",
+	"api",
+	"layout",
+	"middleware",
+	"reuse",
+	"cron",
+	"plugin"
+];
+const pageCommand = {
+	meta: {
+		name: "page",
+		description: "Scaffold pages, api routes, layouts, middleware, crons, and plugins"
+	},
+	subCommands: {
+		add: {
+			meta: {
+				name: "add",
+				description: "Add a new page, api route, layout, middleware, cron, or plugin"
+			},
+			args: {
+				path: {
+					type: "positional",
+					description: "Route path (e.g., users/[id], api/users, crons/daily)"
+				},
+				type: {
+					type: "string",
+					description: "Type: page, api, layout, middleware, cron, plugin",
+					default: "page"
+				},
+				method: {
+					type: "string",
+					description: "HTTP method for API routes (GET, POST, etc.)",
+					default: "GET"
+				},
+				schedule: {
+					type: "string",
+					description: "Cron schedule expression for cron tasks",
+					default: "* * * * *"
+				},
+				force: {
+					type: "boolean",
+					description: "Overwrite existing files (creates .bak backup)",
+					default: false,
+					alias: "f"
+				},
+				dry: {
+					type: "boolean",
+					description: "Show what would be created without writing files",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const type = args.type;
+				if (!scaffoldTypes.includes(type)) {
+					logger.error(`Invalid type: ${type}. Must be one of: ${scaffoldTypes.join(", ")}`);
+					return;
+				}
+				const result = await scaffold({
+					cwd: process.cwd(),
+					type,
+					path: args.path,
+					method: args.method,
+					schedule: args.schedule,
+					force: args.force,
+					dry: args.dry
+				});
+				for (const file of result.created) logger.success(`${args.dry ? "[dry-run] Would create" : "Created"} ${file}`);
+				for (const file of result.skipped) logger.warn(`Skipped ${file} (already exists, use --force to overwrite)`);
+				for (const err of result.errors) logger.error(err);
+			}
+		},
+		"add-reuse": {
+			meta: {
+				name: "add-reuse",
+				description: "Add a new reusable page component (.reuse.ts)"
+			},
+			args: {
+				path: {
+					type: "positional",
+					description: "Reusable page path (e.g., users/[id])"
+				},
+				force: {
+					type: "boolean",
+					description: "Overwrite existing files (creates .bak backup)",
+					default: false,
+					alias: "f"
+				},
+				dry: {
+					type: "boolean",
+					description: "Show what would be created without writing files",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const result = await scaffold({
+					cwd: process.cwd(),
+					type: "reuse",
+					path: args.path,
+					force: args.force,
+					dry: args.dry
+				});
+				for (const file of result.created) logger.success(`${args.dry ? "[dry-run] Would create" : "Created"} ${file}`);
+				for (const file of result.skipped) logger.warn(`Skipped ${file} (already exists, use --force to overwrite)`);
+				for (const err of result.errors) logger.error(err);
+			}
+		},
+		delete: {
+			meta: {
+				name: "delete",
+				description: "Delete a scaffold file (creates backup by default)"
+			},
+			args: {
+				path: {
+					type: "positional",
+					description: "Path to delete"
+				},
+				type: {
+					type: "string",
+					description: "Type: page, api, layout, middleware, reuse, cron, plugin",
+					default: "page"
+				},
+				force: {
+					type: "boolean",
+					description: "Delete permanently without creating backup",
+					default: false,
+					alias: "f"
+				},
+				dry: {
+					type: "boolean",
+					description: "Show what would be deleted",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const type = args.type;
+				if (!allTypes.includes(type)) {
+					logger.error(`Invalid type: ${type}. Must be one of: ${allTypes.join(", ")}`);
+					return;
+				}
+				const result = await deleteScaffold({
+					cwd: process.cwd(),
+					type,
+					path: args.path,
+					force: args.force,
+					dry: args.dry
+				});
+				for (const file of result.deleted) logger.success(`${args.dry ? "[dry-run] Would delete" : args.force ? "Deleted" : "Deleted (backup created)"} ${file}`);
+				for (const err of result.errors) logger.error(err);
+			}
+		},
+		recovery: {
+			meta: {
+				name: "recovery",
+				description: "Recover a deleted file from .bak backup"
+			},
+			args: {
+				path: {
+					type: "positional",
+					description: "Path to recover"
+				},
+				type: {
+					type: "string",
+					description: "Type: page, api, layout, middleware, reuse, cron, plugin",
+					default: "page"
+				},
+				dry: {
+					type: "boolean",
+					description: "Check if recovery is possible",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const type = args.type;
+				if (!allTypes.includes(type)) {
+					logger.error(`Invalid type: ${type}. Must be one of: ${allTypes.join(", ")}`);
+					return;
+				}
+				const result = await recoverScaffold({
+					cwd: process.cwd(),
+					type,
+					path: args.path,
+					dry: args.dry
+				});
+				for (const file of result.restored) logger.success(`${args.dry ? "[dry-run] Backup exists for" : "Recovered"} ${file}`);
+				for (const err of result.errors) logger.error(err);
+			}
+		},
+		list: {
+			meta: {
+				name: "list",
+				description: "List existing scaffoldable files"
+			},
+			args: { type: {
+				type: "string",
+				description: "Type to list: page, api, layout, middleware, reuse, cron, plugin",
+				default: "page"
+			} },
+			async run({ args }) {
+				const type = args.type;
+				const files = await listScaffoldableFiles(process.cwd(), type);
+				if (files.length === 0) {
+					logger.info(`No ${type} files found`);
+					return;
+				}
+				logger.info(`Found ${files.length} ${type}(s):`);
+				for (const file of files) logger.log(`  ${file}`);
+			}
+		}
+	}
+};
+//#endregion
+export { createFsOps as S, renderPluginTemplate as _, scaffold as a, toKebabCase as b, LAYOUT_TEMPLATE as c, PLUGIN_TEMPLATE as d, renderApiTemplate as f, renderPageTemplate as g, renderMiddlewareTemplate as h, recoverScaffold as i, MIDDLEWARE_TEMPLATE as l, renderLayoutTemplate as m, listScaffoldableFiles as n, API_TEMPLATE as o, renderCronTemplate as p, pageCommand as r, CRON_TEMPLATE as s, deleteScaffold as t, PAGE_TEMPLATE as u, renderTemplate as v, toPascalCase as x, toCamelCase as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ubean/cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "CLI for ubean (ubean-next binary: dev, build, prepare, init, preview, page, env, config, devtools, api/layout/middleware/cron/plugin scaffolds)",
   "bin": {
     "ubean-next": "./bin/ubean-next.mjs"
@@ -28,15 +28,15 @@
     "consola": "^3.4.2",
     "kolorist": "^1.8.0",
     "pathe": "^2.0.3",
-    "@ubean/app": "0.1.1",
-    "@ubean/build": "0.1.1",
-    "@ubean/codegen": "0.1.1",
-    "@ubean/config": "0.1.1",
-    "@ubean/prerender": "0.1.1",
-    "@ubean/preset": "0.1.1",
-    "@ubean/routing": "0.1.1",
-    "@ubean/dev-server": "0.1.1",
-    "@ubean/utils": "0.1.1"
+    "@ubean/app": "0.1.3",
+    "@ubean/codegen": "0.1.3",
+    "@ubean/config": "0.1.3",
+    "@ubean/build": "0.1.3",
+    "@ubean/dev-server": "0.1.3",
+    "@ubean/preset": "0.1.3",
+    "@ubean/prerender": "0.1.3",
+    "@ubean/routing": "0.1.3",
+    "@ubean/utils": "0.1.3"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",
@@ -44,7 +44,7 @@
     "vite-plus": "0.2.6"
   },
   "peerDependencies": {
-    "@ubean/devtools": "0.1.1"
+    "@ubean/devtools": "0.1.3"
   },
   "peerDependenciesMeta": {
     "@ubean/devtools": {