@kimesh/cli 0.1.0-nightly.20260120063147 → 0.1.1-nightly.20260120033751

package/dist/commands/init.js

@@ -1,198 +0,0 @@
-import { defineCommand } from "citty";
-import consola from "consola";
-import pc from "picocolors";
-import { join, resolve } from "node:path";
-import * as fs from "node:fs";
-
-//#region src/commands/init.ts
-var init_default = defineCommand({
-	meta: {
-		name: "init",
-		description: "Initialize a new Kimesh project in the current directory"
-	},
-	args: {
-		root: {
-			type: "string",
-			alias: "r",
-			description: "Project root directory"
-		},
-		force: {
-			type: "boolean",
-			alias: "f",
-			description: "Overwrite existing files",
-			default: false
-		},
-		typescript: {
-			type: "boolean",
-			alias: "ts",
-			description: "Initialize with TypeScript",
-			default: true
-		}
-	},
-	async run({ args }) {
-		const root = resolve(args.root || process.cwd());
-		consola.info(`Initializing Kimesh project in ${pc.cyan(root)}...`);
-		if (!fs.existsSync(root)) {
-			fs.mkdirSync(root, { recursive: true });
-			consola.log(`  ${pc.green("+")} Created directory: ${root}`);
-		}
-		const configPath = join(root, "kimesh.config.ts");
-		if (fs.existsSync(configPath) && !args.force) {
-			consola.warn(`${pc.yellow("kimesh.config.ts already exists.")} Use ${pc.cyan("--force")} to overwrite.`);
-			return;
-		}
-		const dirs = [
-			"routes",
-			"components",
-			"composables",
-			"utils",
-			"public"
-		];
-		for (const dir of dirs) {
-			const dirPath = join(root, dir);
-			if (!fs.existsSync(dirPath)) {
-				fs.mkdirSync(dirPath, { recursive: true });
-				consola.log(`  ${pc.green("+")} ${dir}/`);
-			} else consola.log(`  ${pc.dim("○")} ${dir}/ (exists)`);
-		}
-		const configContent = `import { defineKmConfig } from '@kimesh/kit'
-
-export default defineKmConfig({
-  // Application name
-  name: '${getProjectName(root)}',
-
-  // Development server options
-  dev: {
-    port: 3000,
-  },
-
-  // Components configuration
-  components: {
-    dirs: ['components'],
-  },
-
-  // Composables configuration
-  composables: {
-    dirs: ['composables'],
-  },
-})
-`;
-		fs.writeFileSync(configPath, configContent);
-		consola.log(`  ${pc.green("+")} kimesh.config.ts`);
-		const appVuePath = join(root, "app.vue");
-		if (!fs.existsSync(appVuePath) || args.force) {
-			const appVueContent = `<script setup lang="ts">
-// Your app setup goes here
-</script>
-
-<template>
-  <router-view />
-</template>
-
-<style>
-:root {
-  --color-primary: #3b82f6;
-  --color-secondary: #6366f1;
-}
-</style>
-`;
-			fs.writeFileSync(appVuePath, appVueContent);
-			consola.log(`  ${pc.green("+")} app.vue`);
-		}
-		const indexRoutePath = join(root, "routes", "index.vue");
-		if (!fs.existsSync(indexRoutePath) || args.force) {
-			const indexRouteContent = `<script setup lang="ts">
-// Home page
-</script>
-
-<template>
-  <div class="home">
-    <h1>Welcome to Kimesh</h1>
-    <p>Your Vue.js application is ready!</p>
-    <p>Edit <code>routes/index.vue</code> to get started.</p>
-  </div>
-</template>
-
-<style scoped>
-.home {
-  max-width: 800px;
-  margin: 0 auto;
-  padding: 2rem;
-  text-align: center;
-}
-
-h1 {
-  color: var(--color-primary);
-}
-
-code {
-  background: #f0f0f0;
-  padding: 0.25rem 0.5rem;
-  border-radius: 4px;
-}
-</style>
-`;
-			fs.writeFileSync(indexRoutePath, indexRouteContent);
-			consola.log(`  ${pc.green("+")} routes/index.vue`);
-		}
-		if (args.typescript) {
-			const tsconfigPath = join(root, "tsconfig.json");
-			if (!fs.existsSync(tsconfigPath) || args.force) {
-				const tsconfigContent = `{
-  "extends": "./.kimesh/tsconfig.json",
-  "compilerOptions": {
-    "strict": true
-  }
-}
-`;
-				fs.writeFileSync(tsconfigPath, tsconfigContent);
-				consola.log(`  ${pc.green("+")} tsconfig.json`);
-			}
-		}
-		const gitignorePath = join(root, ".gitignore");
-		if (!fs.existsSync(gitignorePath) || args.force) {
-			const gitignoreContent = `# Dependencies
-node_modules/
-
-# Build output
-dist/
-.kimesh/
-
-# Environment
-.env
-.env.local
-.env.*.local
-
-# Logs
-*.log
-
-# Editor
-.vscode/
-.idea/
-
-# OS
-.DS_Store
-Thumbs.db
-`;
-			fs.writeFileSync(gitignorePath, gitignoreContent);
-			consola.log(`  ${pc.green("+")} .gitignore`);
-		}
-		consola.log("");
-		consola.success(`Kimesh project initialized!`);
-		consola.log("");
-		consola.info("Next steps:");
-		consola.log(`  1. Install dependencies: ${pc.cyan("bun install")}`);
-		consola.log(`  2. Prepare TypeScript: ${pc.cyan("kmi prepare")}`);
-		consola.log(`  3. Start dev server: ${pc.cyan("kmi dev")}`);
-	}
-});
-/**
-* Get project name from directory path
-*/
-function getProjectName(root) {
-	const basename = root.split(/[/\\]/).pop() || "my-app";
-	return basename.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-}
-
-//#endregion
-export { init_default as default };

package/dist/dev-o5sR0-kW.js

@@ -1,75 +0,0 @@
-import { loadKit } from "./kit-BcEYldTS.js";
-import { devArgs } from "./_shared-CEwpPT2B.js";
-import { defineCommand } from "citty";
-import consola from "consola";
-import pc from "picocolors";
-import { resolve } from "node:path";
-
-//#region src/commands/dev.ts
-var dev_default = defineCommand({
-	meta: {
-		name: "dev",
-		description: "Start development server"
-	},
-	args: devArgs,
-	async run({ args }) {
-		const root = resolve(args.root || process.cwd());
-		const kit = await loadKit(root);
-		const { loadConfig, kimeshPlugin } = kit;
-		const kmConfig = await loadConfig({
-			root,
-			configFile: args.config
-		});
-		const enabledLayers = parseLayersArg(args.layers);
-		const excludedLayers = args["exclude-layers"] ? args["exclude-layers"].split(",").map((l) => l.trim()) : [];
-		consola.info(`Starting ${pc.cyan(kmConfig.name || "Kimesh")} dev server...`);
-		if (enabledLayers === "all") consola.info(`Layers: ${pc.green("all")}`);
-		else if (enabledLayers === "none") consola.info(`Layers: ${pc.yellow("none (host only)")}`);
-		else if (Array.isArray(enabledLayers)) consola.info(`Layers: ${pc.cyan(enabledLayers.join(", "))}`);
-		if (excludedLayers.length > 0) consola.info(`Excluded: ${pc.yellow(excludedLayers.join(", "))}`);
-		const { createServer } = await import("vite");
-		const port = args.port ? parseInt(args.port, 10) : kmConfig.dev?.port ?? 3e3;
-		const host = args.host ?? kmConfig.dev?.host ?? "localhost";
-		const open = args.open ?? kmConfig.dev?.open ?? false;
-		const server = await createServer({
-			root,
-			configFile: false,
-			plugins: [kimeshPlugin({
-				config: kmConfig,
-				layers: {
-					enabled: enabledLayers,
-					excluded: excludedLayers
-				}
-			})],
-			server: {
-				port,
-				host,
-				open
-			}
-		});
-		await server.listen();
-		server.printUrls();
-		consola.success(`Dev server started!`);
-		const cleanup = async () => {
-			consola.info("Shutting down...");
-			await server.close();
-			process.exit(0);
-		};
-		process.on("SIGINT", cleanup);
-		process.on("SIGTERM", cleanup);
-	}
-});
-/**
-* Parse the --layers argument
-*/
-function parseLayersArg(arg) {
-	const envLayers = process.env.KM_LAYERS;
-	const layersArg = arg ?? envLayers;
-	if (!layersArg) return "all";
-	if (layersArg === "all") return "all";
-	if (layersArg === "none") return "none";
-	return layersArg.split(",").map((l) => l.trim()).filter(Boolean);
-}
-
-//#endregion
-export { dev_default as default };

package/dist/generate-Dx64ract.js

@@ -1,21 +0,0 @@
-import { sharedArgs } from "./_shared-CEwpPT2B.js";
-import { defineCommand } from "citty";
-import consola from "consola";
-import pc from "picocolors";
-
-//#region src/commands/generate.ts
-var generate_default = defineCommand({
-	meta: {
-		name: "generate",
-		description: "Generate routes and types"
-	},
-	args: sharedArgs,
-	async run({ args: _args }) {
-		consola.info(`Generating routes and types...`);
-		consola.warn(pc.yellow("Route generation will be available in Phase 2"));
-		consola.success(`Generation complete!`);
-	}
-});
-
-//#endregion
-export { generate_default as default };

package/dist/kit-BcEYldTS.js

@@ -1,39 +0,0 @@
-import consola from "consola";
-import { pathToFileURL } from "node:url";
-import { resolveModulePath } from "exsolve";
-
-//#region src/utils/kit.ts
-let _kit;
-/**
-* Dynamically load @kimesh/kit from the project context
-* Falls back to bundled version if not found
-*/
-async function loadKit(root = process.cwd()) {
-	if (_kit) return _kit;
-	try {
-		const kitPath = resolveModulePath("@kimesh/kit", { from: root });
-		const kitUrl = pathToFileURL(kitPath).href;
-		_kit = await import(kitUrl);
-		consola.debug(`Loaded @kimesh/kit from: ${kitPath}`);
-	} catch {
-		consola.debug("Using bundled @kimesh/kit");
-		_kit = await import("@kimesh/kit");
-	}
-	return _kit;
-}
-/**
-* Get cached kit instance or throw if not loaded
-*/
-function getKit() {
-	if (!_kit) throw new Error("@kimesh/kit not loaded. Call loadKit() first.");
-	return _kit;
-}
-/**
-* Clear kit cache (useful for testing)
-*/
-function clearKitCache() {
-	_kit = void 0;
-}
-
-//#endregion
-export { clearKitCache, getKit, loadKit };

package/dist/layer-D829AuwM.js

@@ -1,258 +0,0 @@
-import { loadKit } from "./kit-BcEYldTS.js";
-import { sharedArgs } from "./_shared-CEwpPT2B.js";
-import { defineCommand } from "citty";
-import consola from "consola";
-import pc from "picocolors";
-import { join, resolve } from "node:path";
-import * as fs from "node:fs";
-
-//#region src/commands/layer.ts
-var layer_default = defineCommand({
-	meta: {
-		name: "layer",
-		description: "Manage Kimesh layers"
-	},
-	subCommands: {
-		list: defineCommand({
-			meta: {
-				name: "list",
-				description: "List available layers"
-			},
-			args: sharedArgs,
-			async run({ args }) {
-				const root = resolve(typeof args.root === "string" ? args.root : process.cwd());
-				const kit = await loadKit(root);
-				const { loadConfig } = kit;
-				const kmConfig = await loadConfig({ root });
-				consola.info(`${pc.cyan("Available layers:")}\n`);
-				const extendsLayers = kmConfig.extends || [];
-				if (extendsLayers.length > 0) {
-					consola.log(pc.bold("From config (extends):"));
-					for (const layer of extendsLayers) {
-						const name = typeof layer === "string" ? layer : layer.name;
-						consola.log(`  ${pc.green("✓")} ${name}`);
-					}
-					consola.log("");
-				}
-				const layersDir = join(root, "layers");
-				if (fs.existsSync(layersDir)) {
-					const entries = fs.readdirSync(layersDir, { withFileTypes: true });
-					const layers = entries.filter((e) => e.isDirectory());
-					if (layers.length > 0) {
-						consola.log(pc.bold("Auto-discovered (layers/):"));
-						for (const layer of layers) {
-							const layerPath = join(layersDir, layer.name);
-							const hasConfig = fs.existsSync(join(layerPath, "kimesh.config.ts"));
-							const hasRoutes = fs.existsSync(join(layerPath, "routes"));
-							const hasComponents = fs.existsSync(join(layerPath, "components"));
-							const hasComposables = fs.existsSync(join(layerPath, "composables"));
-							const features = [
-								hasConfig ? "config" : null,
-								hasRoutes ? "routes" : null,
-								hasComponents ? "components" : null,
-								hasComposables ? "composables" : null
-							].filter(Boolean).join(", ");
-							consola.log(`  ${pc.green("✓")} ${layer.name} ${pc.dim(`(${features})`)}`);
-						}
-					}
-				} else consola.log(pc.dim("No layers/ directory found"));
-			}
-		}),
-		info: defineCommand({
-			meta: {
-				name: "info",
-				description: "Show detailed information about a layer"
-			},
-			args: {
-				name: {
-					type: "positional",
-					description: "Layer name",
-					required: true
-				},
-				...sharedArgs
-			},
-			async run({ args }) {
-				const root = resolve(typeof args.root === "string" ? args.root : process.cwd());
-				const layerName = args.name;
-				const layerPath = join(root, "layers", layerName);
-				if (!fs.existsSync(layerPath)) {
-					consola.error(`Layer not found: ${layerName}`);
-					consola.info(`Checked: ${layerPath}`);
-					process.exit(1);
-				}
-				consola.log(`\n${pc.cyan(pc.bold(`Layer: ${layerName}`))}\n`);
-				consola.log(`${pc.bold("Path:")} ${layerPath}`);
-				const structure = [];
-				const checkDir = (dir, label) => {
-					const fullPath = join(layerPath, dir);
-					if (fs.existsSync(fullPath)) {
-						const files = fs.readdirSync(fullPath);
-						structure.push(`${label}: ${files.length} files`);
-					}
-				};
-				checkDir("routes", "Routes");
-				checkDir("components", "Components");
-				checkDir("composables", "Composables");
-				checkDir("utils", "Utilities");
-				checkDir("stores", "Stores");
-				if (structure.length > 0) {
-					consola.log(`\n${pc.bold("Structure:")}`);
-					for (const item of structure) consola.log(`  ${pc.green("•")} ${item}`);
-				}
-				const configPath = join(layerPath, "kimesh.config.ts");
-				if (fs.existsSync(configPath)) consola.log(`\n${pc.bold("Config:")} ${pc.green("Found")}`);
-			}
-		}),
-		create: defineCommand({
-			meta: {
-				name: "create",
-				description: "Create a new layer scaffold"
-			},
-			args: {
-				name: {
-					type: "positional",
-					description: "Layer name",
-					required: true
-				},
-				basePath: {
-					type: "string",
-					alias: "b",
-					description: "Base path for routes (e.g., /cms)"
-				},
-				...sharedArgs
-			},
-			async run({ args }) {
-				const root = resolve(typeof args.root === "string" ? args.root : process.cwd());
-				const layerName = args.name;
-				const basePath = args.basePath || `/${layerName}`;
-				const layersDir = join(root, "layers");
-				const layerPath = join(layersDir, layerName);
-				if (fs.existsSync(layerPath)) {
-					consola.error(`Layer already exists: ${layerPath}`);
-					process.exit(1);
-				}
-				consola.info(`Creating layer: ${pc.cyan(layerName)}`);
-				const dirs = [
-					"",
-					"routes",
-					"components",
-					"composables",
-					"utils",
-					"stores"
-				];
-				for (const dir of dirs) {
-					const dirPath = join(layerPath, dir);
-					fs.mkdirSync(dirPath, { recursive: true });
-					consola.log(`  ${pc.green("+")} ${dir || layerName}/`);
-				}
-				const configContent = `import { defineKmConfig } from '@kimesh/kit'
-
-export default defineKmConfig({
-  name: '${layerName}',
-
-  // Base path for all routes in this layer
-  basePath: '${basePath}',
-
-  // Routes configuration
-  routes: {
-    basePath: '${basePath}',
-    folder: 'routes',
-  },
-
-  // Component configuration
-  components: {
-    dirs: ['components'],
-    prefix: '${toPascalCase(layerName)}',
-  },
-
-  // Composable configuration
-  composables: {
-    dirs: ['composables'],
-  },
-})
-`;
-				fs.writeFileSync(join(layerPath, "kimesh.config.ts"), configContent);
-				consola.log(`  ${pc.green("+")} kimesh.config.ts`);
-				const indexRouteContent = `<script setup lang="ts">
-// ${layerName} layer index route
-</script>
-
-<template>
-  <div class="${layerName}-index">
-    <h1>${toPascalCase(layerName)} Layer</h1>
-    <p>Welcome to the ${layerName} layer.</p>
-  </div>
-</template>
-`;
-				fs.writeFileSync(join(layerPath, "routes", "index.vue"), indexRouteContent);
-				consola.log(`  ${pc.green("+")} routes/index.vue`);
-				const layoutContent = `<script setup lang="ts">
-// ${layerName} layer layout
-</script>
-
-<template>
-  <div class="${layerName}-layout">
-    <slot />
-  </div>
-</template>
-`;
-				fs.writeFileSync(join(layerPath, "routes", "_layout.vue"), layoutContent);
-				consola.log(`  ${pc.green("+")} routes/_layout.vue`);
-				consola.success(`\nLayer created at: ${pc.cyan(layerPath)}`);
-				consola.info(`\nNext steps:`);
-				consola.log(`  1. Add to your config: extends: ['./${join("layers", layerName)}']`);
-				consola.log(`  2. Start dev server: ${pc.cyan("kmi dev")}`);
-				consola.log(`  3. Visit: ${pc.cyan(`http://localhost:3000${basePath}`)}`);
-			}
-		}),
-		validate: defineCommand({
-			meta: {
-				name: "validate",
-				description: "Validate layer configurations"
-			},
-			args: sharedArgs,
-			async run({ args }) {
-				const root = resolve(typeof args.root === "string" ? args.root : process.cwd());
-				consola.info("Validating layers...\n");
-				const layersDir = join(root, "layers");
-				let errors = 0;
-				let warnings = 0;
-				if (!fs.existsSync(layersDir)) {
-					consola.info("No layers/ directory found");
-					return;
-				}
-				const entries = fs.readdirSync(layersDir, { withFileTypes: true });
-				const layers = entries.filter((e) => e.isDirectory());
-				for (const layer of layers) {
-					const layerPath = join(layersDir, layer.name);
-					consola.log(`${pc.bold(layer.name)}:`);
-					const hasRoutes = fs.existsSync(join(layerPath, "routes"));
-					const hasComponents = fs.existsSync(join(layerPath, "components"));
-					const hasComposables = fs.existsSync(join(layerPath, "composables"));
-					const hasConfig = fs.existsSync(join(layerPath, "kimesh.config.ts"));
-					if (!hasRoutes && !hasComponents && !hasComposables) {
-						consola.log(`  ${pc.yellow("⚠")} No routes/, components/, or composables/ directory`);
-						warnings++;
-					} else consola.log(`  ${pc.green("✓")} Valid layer structure`);
-					if (!hasConfig) consola.log(`  ${pc.dim("○")} No kimesh.config.ts (using defaults)`);
-					else consola.log(`  ${pc.green("✓")} Has kimesh.config.ts`);
-					consola.log("");
-				}
-				if (errors > 0) {
-					consola.error(`\n${errors} error(s) found`);
-					process.exit(1);
-				} else if (warnings > 0) consola.warn(`\n${warnings} warning(s)`);
-				else consola.success("\nAll layers valid!");
-			}
-		})
-	}
-});
-/**
-* Convert string to PascalCase
-*/
-function toPascalCase(str) {
-	return str.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
-}
-
-//#endregion
-export { layer_default as default };

package/dist/main-CCPXvZyj.d.ts

@@ -1,10 +0,0 @@
-import * as citty0 from "citty";
-
-//#region src/main.d.ts
-declare const version = "0.1.0";
-/**
- * Main CLI command definition
- */
-declare const main: citty0.CommandDef<citty0.ArgsDef>;
-//#endregion
-export { main as main$1, version as version$1 };

package/dist/main-DncTPs_e.js

@@ -1,47 +0,0 @@
-import { defineCommand } from "citty";
-import consola from "consola";
-import pc from "picocolors";
-
-//#region src/commands/index.ts
-/**
-* Command registry with lazy loading
-* Commands are only imported when actually used
-*/
-const commands = {
-	dev: () => import("./dev-o5sR0-kW.js").then((m) => m.default),
-	build: () => import("./build-Ce4Dm8mI.js").then((m) => m.default),
-	generate: () => import("./generate-Dx64ract.js").then((m) => m.default),
-	prepare: () => import("./prepare-DScUWnaY.js").then((m) => m.default),
-	layer: () => import("./layer-D829AuwM.js").then((m) => m.default),
-	init: () => import("./commands/init.js").then((m) => m.default),
-	start: () => import("./dev-o5sR0-kW.js").then((m) => m.default)
-};
-
-//#endregion
-//#region src/main.ts
-const version = "0.1.0";
-/**
-* Main CLI command definition
-*/
-const main = defineCommand({
-	meta: {
-		name: "kmi",
-		version,
-		description: "Kimesh Framework CLI"
-	},
-	subCommands: {
-		dev: commands.dev,
-		build: commands.build,
-		generate: commands.generate,
-		prepare: commands.prepare,
-		layer: commands.layer,
-		init: commands.init,
-		start: commands.start
-	},
-	setup() {
-		consola.log(pc.cyan(`\n  🚀 Kimesh Framework v${version}\n`));
-	}
-});
-
-//#endregion
-export { commands, main, version };

package/dist/prepare-DScUWnaY.js

@@ -1,45 +0,0 @@
-import { loadKit } from "./kit-BcEYldTS.js";
-import { prepareArgs } from "./_shared-CEwpPT2B.js";
-import { defineCommand } from "citty";
-import consola from "consola";
-import pc from "picocolors";
-import { resolve } from "node:path";
-
-//#region src/commands/prepare.ts
-var prepare_default = defineCommand({
-	meta: {
-		name: "prepare",
-		description: "Generate .kimesh directory for TypeScript support"
-	},
-	args: prepareArgs,
-	async run({ args }) {
-		const root = resolve(args.root || process.cwd());
-		const startTime = Date.now();
-		consola.info(`Preparing ${pc.cyan(root)}...`);
-		const kit = await loadKit(root);
-		const { prepare } = kit;
-		try {
-			const result = await prepare({
-				root,
-				configFile: args.config,
-				verbose: args.verbose
-			});
-			const duration = Date.now() - startTime;
-			consola.success(`Prepared in ${pc.cyan(`${duration}ms`)}`);
-			consola.info(`  ${pc.gray("Build directory:")} ${pc.cyan(result.buildDir)}`);
-			consola.info(`  ${pc.gray("Layers:")} ${pc.cyan(result.layerCount.toString())}`);
-			consola.info(`  ${pc.gray("Aliases:")} ${pc.cyan(result.aliasCount.toString())}`);
-			consola.info(`  ${pc.gray("Generated files:")} ${pc.cyan(result.generatedFiles.join(", "))}`);
-			consola.log("");
-			consola.info(`${pc.green("✓")} TypeScript is now ready! Your IDE should recognize path aliases.`);
-			consola.log("");
-			consola.info(`${pc.gray("Tip:")} Make sure your ${pc.cyan("tsconfig.json")} extends ${pc.cyan(".kimesh/tsconfig.json")}`);
-		} catch (error) {
-			consola.error("Failed to prepare project:", error);
-			process.exit(1);
-		}
-	}
-});
-
-//#endregion
-export { prepare_default as default };