@kimesh/cli 0.1.1 → 0.2.0-nightly.20260120083917

package/dist/layer-D829AuwM.js

@@ -0,0 +1,258 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,47 @@
+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/main.d.ts

@@ -1,2 +1,2 @@
-import { main, version } from "../../km/src/index";
+import { main$1 as main, version$1 as version } from "./main-CCPXvZyj.js";
 export { main, version };

package/dist/main.js

@@ -1,3 +1,3 @@
-import { main, version } from "../../km/src/index";
+import { main, version } from "./main-DncTPs_e.js";
 
 export { main, version };

package/dist/prepare-DScUWnaY.js

@@ -0,0 +1,45 @@
+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 };

package/dist/run-DCL2u7IK.js

@@ -0,0 +1,15 @@
+import { main } from "./main-DncTPs_e.js";
+import { runMain } from "citty";
+
+//#region src/run.ts
+/**
+* Run the CLI
+* This is the entry point when the CLI is invoked directly
+*/
+function run() {
+	runMain(main);
+}
+run();
+
+//#endregion
+export { run };

package/dist/run-DiuH8yNF.d.ts

@@ -0,0 +1,8 @@
+//#region src/run.d.ts
+/**
+ * Run the CLI
+ * This is the entry point when the CLI is invoked directly
+ */
+declare function run(): void;
+//#endregion
+export { run as run$1 };

package/dist/run.d.ts

@@ -1,2 +1,2 @@
-import { run } from "../../km/src/index";
+import { run$1 as run } from "./run-DiuH8yNF.js";
 export { run };

package/dist/run.js

@@ -1,7 +1,4 @@
-import { run } from "../../km/src/index";
+import "./main-DncTPs_e.js";
+import { run } from "./run-DCL2u7IK.js";
 
-//#region src/run.ts
-run();
-
-//#endregion
 export { run };

package/package.json

@@ -1,20 +1,28 @@
 {
   "name": "@kimesh/cli",
-  "version": "0.1.1",
-  "description": "Kimesh CLI for integration with main package",
+  "version": "0.2.0-nightly.20260120083917",
+  "description": "Kimesh Framework CLI",
   "type": "module",
+  "bin": {
+    "km": "./bin/km.mjs",
+    "kimesh": "./bin/km.mjs"
+  },
   "exports": {
     ".": {
-      "types": "./dist/index.d.mts",
-      "import": "./dist/index.mjs"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     },
-    "./cli": "./bin/km.mjs"
-  },
-  "main": "./dist/index.mjs",
-  "types": "./dist/index.d.mts",
-  "bin": {
-    "km": "bin/km.mjs"
+    "./cli": {
+      "types": "./dist/run.d.ts",
+      "import": "./dist/run.js"
+    },
+    "./commands/init": {
+      "types": "./dist/commands/init.d.ts",
+      "import": "./dist/commands/init.js"
+    }
   },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist",
     "bin"
@@ -25,10 +33,23 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@kimesh/km": "0.1.1"
+    "@kimesh/kit": "0.2.0-nightly.20260120083917",
+    "citty": "^0.1.6",
+    "consola": "^3.4.2",
+    "exsolve": "^1.0.8",
+    "picocolors": "^1.1.1"
   },
   "devDependencies": {
+    "@types/node": "^22.13.1",
     "tsdown": "^0.11.7",
     "typescript": "^5.8.2"
+  },
+  "peerDependencies": {
+    "vite": "^6.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
   }
 }