create-kimesh 0.1.0-nightly.20260120033244 → 0.1.0-nightly.20260120082346

package/bin/create-kimesh.mjs

@@ -1,11 +1,3 @@
 #!/usr/bin/env node
 
-import { fileURLToPath } from "node:url";
-import { runMain } from "../dist/index.js";
-
-globalThis.__kimesh_cli__ = {
-  startTime: Date.now(),
-  entry: fileURLToPath(import.meta.url),
-};
-
-runMain();
+import('../dist/run.js').then(m => m.run()).catch(console.error)

package/dist/index.d.ts

@@ -1,3 +1,144 @@
-import { main$1 as main, version$1 as version } from "./main-oBZSa6Es.js";
-import { runMain$1 as runMain } from "./index-yXGND_OU.js";
-export { main, runMain, version };
+import { main$1 as main } from "./main-BD9ZzEkl.js";
+
+//#region src/types.d.ts
+/**
+ * Module metadata for CLI display and dependency resolution
+ */
+interface ModuleDefinition {
+  /** Unique identifier matching npm package suffix */
+  id: string;
+  /** Display name for prompts */
+  label: string;
+  /** Short description shown in multiselect */
+  hint: string;
+  /** NPM package name */
+  npmPackage: string;
+  /** Module IDs this module depends on */
+  dependsOn?: string[];
+  /** Order priority for installation - lower = first */
+  installOrder: number;
+}
+/**
+ * Result of dependency resolution
+ */
+interface ResolvedModules {
+  /** Modules to install - in dependency order */
+  modules: ModuleDefinition[];
+  /** Modules that were auto-added due to dependencies */
+  autoAdded: ModuleDefinition[];
+}
+/**
+ * User options collected from prompts
+ */
+interface CreateOptions {
+  /** Project directory name */
+  projectName: string;
+  /** Resolved absolute path to project directory */
+  projectPath: string;
+  /** Template to scaffold from */
+  template: string;
+  /** Selected modules to install */
+  modules: string[];
+  /** Force override existing directory */
+  force: boolean;
+}
+/**
+ * Directory conflict resolution action
+ */
+type ConflictAction = "override" | "different" | "abort";
+//#endregion
+//#region src/modules/registry.d.ts
+/**
+ * Available modules for create-kimesh
+ */
+declare const AVAILABLE_MODULES: ModuleDefinition[];
+/**
+ * Get module by ID
+ */
+declare function getModule(id: string): ModuleDefinition | undefined;
+/**
+ * Get all module IDs
+ */
+declare function getModuleIds(): string[];
+/**
+ * Check if a module ID is valid
+ */
+declare function isValidModuleId(id: string): boolean;
+/**
+ * Parse comma-separated module string into array of valid module IDs
+ */
+declare function parseModulesArg(modules: string): string[];
+//#endregion
+//#region src/modules/resolver.d.ts
+/**
+ * Resolve module dependencies and return ordered list
+ *
+ * @param selectedIds - Array of module IDs selected by the user
+ * @returns ResolvedModules with ordered modules and auto-added dependencies
+ */
+declare function resolveModules(selectedIds: string[]): ResolvedModules;
+/**
+ * Check if a module has unmet dependencies in the selection
+ */
+declare function hasUnmetDependencies(moduleId: string, selectedIds: string[]): string[];
+/**
+ * Get display string for module with dependency info
+ */
+declare function getModuleDisplayHint(module: ModuleDefinition): string;
+//#endregion
+//#region src/prompts/project-name.d.ts
+/**
+ * Validate a project name
+ * @returns true if valid, error message string if invalid
+ */
+declare function validateProjectName(name: string): true | string;
+/**
+ * Prompt the user for a project name
+ *
+ * @param defaultName - Default project name to suggest
+ * @returns The validated project name
+ */
+declare function promptProjectName(defaultName?: string): Promise<string>;
+//#endregion
+//#region src/prompts/directory-conflict.d.ts
+/**
+ * Prompt user to resolve a directory conflict
+ *
+ * @param dirname - The name of the existing directory
+ * @returns The chosen action: 'override', 'different', or 'abort'
+ */
+declare function promptDirectoryConflict(dirname: string): Promise<ConflictAction>;
+/**
+ * Prompt user for a new directory name
+ *
+ * @param currentName - The current (conflicting) name
+ * @returns The new directory name
+ */
+declare function promptNewDirectoryName(currentName: string): Promise<string>;
+//#endregion
+//#region src/prompts/module-selection.d.ts
+/**
+ * Prompt user to select modules from the available list
+ *
+ * @returns Array of selected module IDs
+ */
+declare function promptModuleSelection(): Promise<string[]>;
+//#endregion
+//#region src/scaffold/index.d.ts
+interface ScaffoldOptions {
+  projectPath: string;
+  projectName: string;
+  template: string;
+  modules: ModuleDefinition[];
+  override: boolean;
+}
+interface ScaffoldResult {
+  success: boolean;
+  error?: string;
+}
+/**
+ * Scaffold a new Kimesh project with the given options
+ */
+declare function scaffoldProject(options: ScaffoldOptions): Promise<ScaffoldResult>;
+//#endregion
+export { AVAILABLE_MODULES, ConflictAction, CreateOptions, ModuleDefinition, ResolvedModules, ScaffoldOptions, ScaffoldResult, getModule, getModuleDisplayHint, getModuleIds, hasUnmetDependencies, isValidModuleId, main, parseModulesArg, promptDirectoryConflict, promptModuleSelection, promptNewDirectoryName, promptProjectName, resolveModules, scaffoldProject, validateProjectName };

package/dist/index.js

@@ -1,4 +1,3 @@
-import { main, version } from "./main-CV1B6u3V.js";
-import { runMain } from "./src-BRiqFWwv.js";
+import { AVAILABLE_MODULES, getModule, getModuleDisplayHint, getModuleIds, hasUnmetDependencies, isValidModuleId, main, parseModulesArg, promptDirectoryConflict, promptModuleSelection, promptNewDirectoryName, promptProjectName, resolveModules, scaffoldProject, validateProjectName } from "./main-DgdkY0zh.js";
 
-export { main, runMain, version };
+export { AVAILABLE_MODULES, getModule, getModuleDisplayHint, getModuleIds, hasUnmetDependencies, isValidModuleId, main, parseModulesArg, promptDirectoryConflict, promptModuleSelection, promptNewDirectoryName, promptProjectName, resolveModules, scaffoldProject, validateProjectName };

package/dist/{main-oBZSa6Es.d.ts → main-BD9ZzEkl.d.ts}

@@ -1,25 +1,28 @@
 import * as citty0 from "citty";
 
 //#region src/main.d.ts
-declare const version = "0.1.0";
 declare const main: citty0.CommandDef<{
-  root: {
+  dir: {
+    type: "positional";
+    description: string;
+    required: false;
+  };
+  template: {
     type: "string";
-    alias: string;
     description: string;
+    alias: string;
   };
   force: {
     type: "boolean";
-    alias: string;
     description: string;
+    alias: string;
     default: false;
   };
-  typescript: {
-    type: "boolean";
-    alias: string;
+  modules: {
+    type: "string";
     description: string;
-    default: true;
+    alias: string;
   };
 }>;
 //#endregion
-export { main as main$1, version as version$1 };
+export { main as main$1 };

package/dist/main-DgdkY0zh.js

@@ -0,0 +1,712 @@
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { defineCommand } from "citty";
+import consola from "consola";
+import pc from "picocolors";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+
+//#region src/scaffold/index.ts
+/**
+* Scaffold a new Kimesh project with the given options
+*/
+async function scaffoldProject(options) {
+	const { projectPath, projectName, modules, override } = options;
+	try {
+		if (existsSync(projectPath)) if (override) await rm(projectPath, {
+			recursive: true,
+			force: true
+		});
+		else return {
+			success: false,
+			error: `Directory "${projectPath}" already exists`
+		};
+		await mkdir(projectPath, { recursive: true });
+		const packageJson = generatePackageJson(projectName, modules);
+		await writeFile(join(projectPath, "package.json"), JSON.stringify(packageJson, null, 2));
+		const kimeshConfig = generateKimeshConfig(modules);
+		await writeFile(join(projectPath, "kimesh.config.ts"), kimeshConfig);
+		const tsconfig = generateTsConfig();
+		await writeFile(join(projectPath, "tsconfig.json"), JSON.stringify(tsconfig, null, 2));
+		await mkdir(join(projectPath, "src", "routes"), { recursive: true });
+		await mkdir(join(projectPath, "src", "components"), { recursive: true });
+		await mkdir(join(projectPath, "src", "composables"), { recursive: true });
+		await writeFile(join(projectPath, "src", "app.vue"), generateAppVue(modules));
+		await writeFile(join(projectPath, "src", "app.css"), generateAppCss(modules));
+		await writeFile(join(projectPath, "src", "routes", "__root.vue"), generateRootLayout());
+		await writeFile(join(projectPath, "src", "routes", "index.vue"), generateIndexRoute());
+		for (const module of modules) if (module.id === "pinia") await scaffoldPinia(projectPath);
+		await writeFile(join(projectPath, ".gitignore"), generateGitignore());
+		return { success: true };
+	} catch (error) {
+		return {
+			success: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+function generatePackageJson(projectName, modules) {
+	const dependencies = {
+		vue: "^3.5.0",
+		"vue-router": "^4.4.0"
+	};
+	const devDependencies = {
+		kimesh: "workspace:*",
+		typescript: "^5.7.0",
+		vite: "^6.0.0",
+		"@types/node": "^22.0.0"
+	};
+	for (const module of modules) {
+		if (module.id === "tailwindcss") {
+			devDependencies["tailwindcss"] = "^4.0.0";
+			devDependencies["@tailwindcss/vite"] = "^4.0.0";
+			devDependencies["@kimesh/tailwindcss"] = "workspace:*";
+		}
+		if (module.id === "pinia") {
+			dependencies["pinia"] = "^3.0.0";
+			devDependencies["@kimesh/pinia"] = "workspace:*";
+		}
+	}
+	return {
+		name: projectName,
+		version: "0.0.0",
+		private: true,
+		type: "module",
+		scripts: {
+			dev: "km dev",
+			build: "km build",
+			"km:prepare": "km prepare"
+		},
+		dependencies,
+		devDependencies
+	};
+}
+function generateKimeshConfig(modules) {
+	const imports = [];
+	const moduleStrings = [];
+	const moduleOptions = [];
+	for (const module of modules) {
+		if (module.id === "tailwindcss") {
+			imports.push("import tailwindcss from \"@tailwindcss/vite\";");
+			moduleStrings.push("\"@kimesh/tailwindcss\"");
+			moduleOptions.push(`
+  tailwindcss: {
+    autoReference: true,
+    mainCss: "src/app.css",
+  },`);
+		}
+		if (module.id === "pinia") moduleStrings.push("\"@kimesh/pinia\"");
+	}
+	const importsSection = imports.length > 0 ? `${imports.join("\n")}\n\n` : "";
+	const modulesSection = moduleStrings.length > 0 ? `\n  modules: [${moduleStrings.join(", ")}],` : "";
+	const moduleOptionsSection = moduleOptions.join("");
+	const vitePlugins = imports.length > 0 ? `\n\n  vite: {\n    plugins: [tailwindcss()],\n  },` : "";
+	return `import { defineKmConfig } from "@kimesh/kit";
+${importsSection}export default defineKmConfig({
+  name: "kimesh-app",${modulesSection}
+
+  app: {
+    head: {
+      title: "Kimesh App",
+      titleTemplate: "%s | Kimesh",
+      meta: [
+        { charset: "utf-8" },
+        { name: "viewport", content: "width=device-width, initial-scale=1" },
+      ],
+      htmlAttrs: {
+        lang: "en",
+      },
+    },
+  },${moduleOptionsSection}${vitePlugins}
+});
+`;
+}
+function generateTsConfig() {
+	return {
+		compilerOptions: {
+			target: "ES2022",
+			module: "ESNext",
+			moduleResolution: "bundler",
+			strict: true,
+			jsx: "preserve",
+			resolveJsonModule: true,
+			isolatedModules: true,
+			esModuleInterop: true,
+			skipLibCheck: true,
+			baseUrl: ".",
+			paths: { "@/*": ["./src/*"] }
+		},
+		include: ["src/**/*.ts", "src/**/*.vue"],
+		exclude: ["node_modules"]
+	};
+}
+function generateAppVue(modules) {
+	const hasTailwind = modules.some((m) => m.id === "tailwindcss");
+	const cssImport = hasTailwind ? "\nimport \"./app.css\";" : "";
+	return `<script setup lang="ts">
+import { KmOutlet } from "@kimesh/router-runtime";${cssImport}
+</script>
+
+<template>
+  <div id="app">
+    <KmOutlet />
+  </div>
+</template>
+`;
+}
+function generateAppCss(modules) {
+	const hasTailwind = modules.some((m) => m.id === "tailwindcss");
+	if (hasTailwind) return `@import "tailwindcss";
+
+/* Custom styles */
+`;
+	return `/* Global styles */
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+  line-height: 1.6;
+  color: #333;
+}
+
+a {
+  color: #42b883;
+  text-decoration: none;
+}
+
+a:hover {
+  text-decoration: underline;
+}
+`;
+}
+function generateRootLayout() {
+	return `<script lang="ts">
+import { createFileRoute } from "@kimesh/router-runtime";
+
+export const Route = createFileRoute("__root")({
+  head: {
+    // Root layout head config
+  },
+});
+</script>
+
+<script setup lang="ts">
+import { KmOutlet, KmLink } from "@kimesh/router-runtime";
+</script>
+
+<template>
+  <div class="layout">
+    <header>
+      <nav>
+        <KmLink to="/">Home</KmLink>
+      </nav>
+    </header>
+    <main>
+      <KmOutlet />
+    </main>
+  </div>
+</template>
+
+<style scoped>
+.layout {
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+}
+
+header {
+  padding: 1rem 2rem;
+  border-bottom: 1px solid #eee;
+}
+
+nav {
+  display: flex;
+  gap: 1rem;
+}
+
+main {
+  flex: 1;
+  padding: 2rem;
+  max-width: 1200px;
+  margin: 0 auto;
+  width: 100%;
+}
+</style>
+`;
+}
+function generateIndexRoute() {
+	return `<script lang="ts">
+import { createFileRoute } from "@kimesh/router-runtime";
+
+export const Route = createFileRoute("/")({
+  head: {
+    title: "Home",
+    meta: [
+      { name: "description", content: "Welcome to your Kimesh app" },
+    ],
+  },
+});
+</script>
+
+<script setup lang="ts">
+</script>
+
+<template>
+  <div class="home">
+    <h1>Welcome to Kimesh</h1>
+    <p>File-based routing for Vue with nested layouts.</p>
+    
+    <section>
+      <h2>Getting Started</h2>
+      <ul>
+        <li>Edit <code>src/routes/index.vue</code> to modify this page</li>
+        <li>Add new routes in <code>src/routes/</code> folder</li>
+        <li>Create layouts with <code>__root.vue</code> or folder layouts</li>
+      </ul>
+    </section>
+  </div>
+</template>
+
+<style scoped>
+.home {
+  max-width: 800px;
+}
+
+h1 {
+  font-size: 2.5rem;
+  margin-bottom: 1rem;
+  background: linear-gradient(135deg, #42b883, #35495e);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+}
+
+p {
+  font-size: 1.25rem;
+  color: #666;
+  margin-bottom: 2rem;
+}
+
+section {
+  background: #f8f9fa;
+  padding: 1.5rem;
+  border-radius: 8px;
+}
+
+h2 {
+  margin-bottom: 1rem;
+  color: #35495e;
+}
+
+ul {
+  list-style: none;
+  padding: 0;
+}
+
+li {
+  padding: 0.5rem 0;
+  color: #666;
+}
+
+code {
+  background: #e9ecef;
+  padding: 0.2rem 0.4rem;
+  border-radius: 4px;
+  font-size: 0.9em;
+}
+</style>
+`;
+}
+async function scaffoldPinia(projectPath) {
+	await mkdir(join(projectPath, "src", "stores"), { recursive: true });
+	const exampleStore = `import { defineStore } from "pinia";
+import { ref, computed } from "vue";
+
+export const useCounterStore = defineStore("counter", () => {
+  const count = ref(0);
+  const doubleCount = computed(() => count.value * 2);
+
+  function increment() {
+    count.value++;
+  }
+
+  function decrement() {
+    count.value--;
+  }
+
+  return { count, doubleCount, increment, decrement };
+});
+`;
+	await writeFile(join(projectPath, "src", "stores", "counter.ts"), exampleStore);
+}
+function generateGitignore() {
+	return `# Dependencies
+node_modules/
+
+# Build output
+dist/
+.output/
+.kimesh/
+
+# Logs
+*.log
+
+# Editor
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.local
+.env.*.local
+`;
+}
+
+//#endregion
+//#region src/modules/registry.ts
+/**
+* Available modules for create-kimesh
+*/
+const AVAILABLE_MODULES = [
+	{
+		id: "tailwindcss",
+		label: "TailwindCSS",
+		hint: "Utility-first CSS framework",
+		npmPackage: "@kimesh/tailwindcss",
+		installOrder: 1
+	},
+	{
+		id: "shadcn",
+		label: "shadcn/ui",
+		hint: "Re-usable components built with Radix Vue",
+		npmPackage: "@kimesh/shadcn",
+		dependsOn: ["tailwindcss"],
+		installOrder: 2
+	},
+	{
+		id: "pinia",
+		label: "Pinia",
+		hint: "The intuitive store for Vue.js",
+		npmPackage: "@kimesh/pinia",
+		installOrder: 1
+	}
+];
+/**
+* Get module by ID
+*/
+function getModule(id) {
+	return AVAILABLE_MODULES.find((m) => m.id === id);
+}
+/**
+* Get all module IDs
+*/
+function getModuleIds() {
+	return AVAILABLE_MODULES.map((m) => m.id);
+}
+/**
+* Check if a module ID is valid
+*/
+function isValidModuleId(id) {
+	return AVAILABLE_MODULES.some((m) => m.id === id);
+}
+/**
+* Parse comma-separated module string into array of valid module IDs
+*/
+function parseModulesArg(modules) {
+	return modules.split(",").map((m) => m.trim().toLowerCase()).filter((m) => m && isValidModuleId(m));
+}
+
+//#endregion
+//#region src/modules/resolver.ts
+/**
+* Resolve module dependencies and return ordered list
+*
+* @param selectedIds - Array of module IDs selected by the user
+* @returns ResolvedModules with ordered modules and auto-added dependencies
+*/
+function resolveModules(selectedIds) {
+	const selected = new Set(selectedIds);
+	const autoAdded = [];
+	for (const id of selectedIds) {
+		const module = getModule(id);
+		if (!module?.dependsOn) continue;
+		for (const depId of module.dependsOn) if (!selected.has(depId)) {
+			const dep = getModule(depId);
+			if (dep) {
+				selected.add(depId);
+				autoAdded.push(dep);
+			}
+		}
+	}
+	const modules = Array.from(selected).map((id) => getModule(id)).filter((m) => m !== void 0).sort((a, b) => a.installOrder - b.installOrder);
+	return {
+		modules,
+		autoAdded
+	};
+}
+/**
+* Check if a module has unmet dependencies in the selection
+*/
+function hasUnmetDependencies(moduleId, selectedIds) {
+	const module = getModule(moduleId);
+	if (!module?.dependsOn) return [];
+	const selected = new Set(selectedIds);
+	return module.dependsOn.filter((depId) => !selected.has(depId));
+}
+/**
+* Get display string for module with dependency info
+*/
+function getModuleDisplayHint(module) {
+	if (module.dependsOn && module.dependsOn.length > 0) {
+		const deps = module.dependsOn.join(", ");
+		return `${module.hint} (requires ${deps})`;
+	}
+	return module.hint;
+}
+
+//#endregion
+//#region src/prompts/project-name.ts
+/**
+* Validation regex for project names
+* Valid: alphanumeric, hyphens, underscores
+*/
+const PROJECT_NAME_REGEX = /^[\w-]+$/;
+/**
+* Validate a project name
+* @returns true if valid, error message string if invalid
+*/
+function validateProjectName(name) {
+	const trimmed = name.trim();
+	if (!trimmed) return "Project name cannot be empty";
+	if (!PROJECT_NAME_REGEX.test(trimmed)) return "Project name can only contain letters, numbers, hyphens, and underscores";
+	return true;
+}
+/**
+* Prompt the user for a project name
+*
+* @param defaultName - Default project name to suggest
+* @returns The validated project name
+*/
+async function promptProjectName(defaultName = "kimesh-app") {
+	const result = await consola.prompt("What is your project name?", {
+		type: "text",
+		placeholder: defaultName,
+		default: defaultName
+	});
+	if (typeof result === "symbol") {
+		consola.info("Operation cancelled");
+		process.exit(0);
+	}
+	const trimmed = result.trim();
+	const validation = validateProjectName(trimmed);
+	if (validation !== true) {
+		consola.warn(validation);
+		return promptProjectName(defaultName);
+	}
+	return trimmed;
+}
+
+//#endregion
+//#region src/prompts/directory-conflict.ts
+/**
+* Options for handling directory conflicts
+*/
+const CONFLICT_OPTIONS = [
+	{
+		value: "override",
+		label: "Override its contents"
+	},
+	{
+		value: "different",
+		label: "Select a different directory"
+	},
+	{
+		value: "abort",
+		label: "Abort"
+	}
+];
+/**
+* Prompt user to resolve a directory conflict
+*
+* @param dirname - The name of the existing directory
+* @returns The chosen action: 'override', 'different', or 'abort'
+*/
+async function promptDirectoryConflict(dirname) {
+	const result = await consola.prompt(`Directory "${dirname}" already exists. What would you like to do?`, {
+		type: "select",
+		options: CONFLICT_OPTIONS
+	});
+	if (typeof result === "symbol") return "abort";
+	return result;
+}
+/**
+* Prompt user for a new directory name
+*
+* @param currentName - The current (conflicting) name
+* @returns The new directory name
+*/
+async function promptNewDirectoryName(currentName) {
+	const result = await consola.prompt("Enter a new directory name:", {
+		type: "text",
+		placeholder: `${currentName}-new`
+	});
+	if (typeof result === "symbol") {
+		consola.info("Operation cancelled");
+		process.exit(0);
+	}
+	const trimmed = result.trim();
+	if (!trimmed) {
+		consola.warn("Directory name cannot be empty");
+		return promptNewDirectoryName(currentName);
+	}
+	if (!/^[\w-]+$/.test(trimmed)) {
+		consola.warn("Directory name can only contain letters, numbers, hyphens, and underscores");
+		return promptNewDirectoryName(currentName);
+	}
+	return trimmed;
+}
+
+//#endregion
+//#region src/prompts/module-selection.ts
+/**
+* Prompt user to select modules from the available list
+*
+* @returns Array of selected module IDs
+*/
+async function promptModuleSelection() {
+	const options = AVAILABLE_MODULES.map((mod) => ({
+		value: mod.id,
+		label: mod.label,
+		hint: getModuleDisplayHint(mod)
+	}));
+	const result = await consola.prompt("Which modules would you like to include? (space to select, enter to confirm)", {
+		type: "multiselect",
+		options,
+		required: false
+	});
+	if (typeof result === "symbol") {
+		consola.info("Operation cancelled");
+		process.exit(0);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/main.ts
+const main = defineCommand({
+	meta: {
+		name: "create-kimesh",
+		version: "0.1.0",
+		description: "Create a new Kimesh project"
+	},
+	args: {
+		dir: {
+			type: "positional",
+			description: "Project directory",
+			required: false
+		},
+		template: {
+			type: "string",
+			description: "Template to use",
+			alias: "t"
+		},
+		force: {
+			type: "boolean",
+			description: "Override existing directory without prompting",
+			alias: "f",
+			default: false
+		},
+		modules: {
+			type: "string",
+			description: `Comma-separated modules to install (${getModuleIds().join(", ")})`,
+			alias: "m"
+		}
+	},
+	async run({ args }) {
+		consola.log("");
+		consola.log(pc.cyan(pc.bold("  ✨ Create Kimesh App")));
+		consola.log("");
+		const template = args.template || "default";
+		const forceOverride = args.force;
+		let projectName;
+		if (args.dir) {
+			const validation = validateProjectName(args.dir);
+			if (validation !== true) {
+				consola.error(validation);
+				process.exit(1);
+			}
+			projectName = args.dir;
+		} else projectName = await promptProjectName();
+		let projectPath = resolve(process.cwd(), projectName);
+		while (existsSync(projectPath)) {
+			if (forceOverride) {
+				consola.warn(`Directory "${projectName}" exists and will be overridden`);
+				break;
+			}
+			const action = await promptDirectoryConflict(projectName);
+			if (action === "abort") {
+				consola.info("Operation cancelled");
+				process.exit(0);
+			}
+			if (action === "override") {
+				consola.info(`Will override existing directory "${projectName}"`);
+				break;
+			}
+			projectName = await promptNewDirectoryName(projectName);
+			projectPath = resolve(process.cwd(), projectName);
+		}
+		let selectedModuleIds;
+		if (args.modules) {
+			selectedModuleIds = parseModulesArg(args.modules);
+			const inputModules = args.modules.split(",").map((m) => m.trim().toLowerCase());
+			const invalidModules = inputModules.filter((m) => m && !isValidModuleId(m));
+			if (invalidModules.length > 0) consola.warn(`Unknown modules ignored: ${invalidModules.join(", ")}. Available: ${getModuleIds().join(", ")}`);
+		} else selectedModuleIds = await promptModuleSelection();
+		const { modules, autoAdded } = resolveModules(selectedModuleIds);
+		if (autoAdded.length > 0) {
+			const autoAddedNames = autoAdded.map((m) => m.label).join(", ");
+			consola.info(`Auto-adding ${pc.cyan(autoAddedNames)} (required by selected modules)`);
+		}
+		consola.log("");
+		consola.info(pc.bold("Creating project with:"));
+		consola.info(`  ${pc.dim("Name:")} ${pc.cyan(projectName)}`);
+		consola.info(`  ${pc.dim("Path:")} ${pc.cyan(projectPath)}`);
+		consola.info(`  ${pc.dim("Template:")} ${pc.green(template)}`);
+		if (modules.length > 0) {
+			const moduleNames = modules.map((m) => m.label).join(", ");
+			consola.info(`  ${pc.dim("Modules:")} ${pc.magenta(moduleNames)}`);
+		} else consola.info(`  ${pc.dim("Modules:")} ${pc.dim("none")}`);
+		consola.log("");
+		const shouldOverride = forceOverride || existsSync(projectPath);
+		consola.start("Scaffolding project...");
+		const result = await scaffoldProject({
+			projectPath,
+			projectName,
+			template,
+			modules,
+			override: shouldOverride
+		});
+		if (!result.success) {
+			consola.error(`Failed to scaffold project: ${result.error}`);
+			process.exit(1);
+		}
+		consola.success("Project created successfully!");
+		consola.log("");
+		consola.info(pc.bold("Next steps:"));
+		consola.info(`  ${pc.cyan(`cd ${projectName}`)}`);
+		consola.info(`  ${pc.cyan("bun install")}`);
+		consola.info(`  ${pc.cyan("bun dev")}`);
+	}
+});
+
+//#endregion
+export { AVAILABLE_MODULES, getModule, getModuleDisplayHint, getModuleIds, hasUnmetDependencies, isValidModuleId, main, parseModulesArg, promptDirectoryConflict, promptModuleSelection, promptNewDirectoryName, promptProjectName, resolveModules, scaffoldProject, validateProjectName };

package/dist/main.d.ts

@@ -1,2 +1,2 @@
-import { main$1 as main, version$1 as version } from "./main-oBZSa6Es.js";
-export { main, version };
+import { main$1 as main } from "./main-BD9ZzEkl.js";
+export { main };

package/dist/main.js

@@ -1,3 +1,3 @@
-import { main, version } from "./main-CV1B6u3V.js";
+import { main } from "./main-DgdkY0zh.js";
 
-export { main, version };
+export { main };

package/dist/run.d.ts

@@ -1,3 +1,4 @@
-import "./main-oBZSa6Es.js";
-import { runMain$1 as runMain } from "./index-yXGND_OU.js";
-export { runMain };
+//#region src/run.d.ts
+declare function run(): void;
+//#endregion
+export { run };

package/dist/run.js

@@ -1,8 +1,10 @@
-import "./main-CV1B6u3V.js";
-import { runMain } from "./src-BRiqFWwv.js";
+import { main } from "./main-DgdkY0zh.js";
+import { runMain } from "citty";
 
 //#region src/run.ts
-runMain();
+function run() {
+	runMain(main);
+}
 
 //#endregion
-export { runMain };
+export { run };

package/package.json

@@ -1,20 +1,22 @@
 {
   "name": "create-kimesh",
-  "version": "0.1.0-nightly.20260120033244",
+  "version": "0.1.0-nightly.20260120082346",
   "description": "Create a new Kimesh project",
   "type": "module",
+  "bin": {
+    "create-kimesh": "./bin/create-kimesh.mjs"
+  },
   "exports": {
     ".": {
-      "import": "./dist/index.mjs",
-      "types": "./dist/index.d.mts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
-  "bin": {
-    "create-kimesh": "bin/create-kimesh.mjs"
-  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
-    "bin",
-    "dist"
+    "dist",
+    "bin"
   ],
   "scripts": {
     "build": "tsdown",
@@ -23,8 +25,9 @@
   "dependencies": {
     "citty": "^0.1.6",
     "consola": "^3.4.2",
+    "exsolve": "^1.0.8",
     "picocolors": "^1.1.1",
-    "@kimesh/km": "0.1.0-nightly.20260120033244"
+    "giget": "^2.0.0"
   },
   "devDependencies": {
     "@types/node": "^22.13.1",

package/dist/index-yXGND_OU.d.ts

@@ -1,5 +0,0 @@
-//#region src/index.d.ts
-
-declare function runMain(): Promise<void>;
-//#endregion
-export { runMain as runMain$1 };

package/dist/main-CV1B6u3V.js

@@ -1,216 +0,0 @@
-import { defineCommand } from "citty";
-import { join, resolve } from "node:path";
-import * as fs from "node:fs";
-import consola from "consola";
-import pc from "picocolors";
-
-//#region ../km/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
-//#region src/main.ts
-const name = "create-kimesh";
-const version = "0.1.0";
-const description = "Create a new Kimesh project";
-const _main = defineCommand({
-	meta: {
-		name,
-		version,
-		description
-	},
-	args: init_default.args,
-	async setup(ctx) {
-		await init_default.run?.(ctx);
-	}
-});
-const main = _main;
-
-//#endregion
-export { main, version };

package/dist/src-BRiqFWwv.js

@@ -1,10 +0,0 @@
-import { main } from "./main-CV1B6u3V.js";
-import { runCommand } from "citty";
-
-//#region src/index.ts
-async function runMain() {
-	await runCommand(main, { rawArgs: process.argv.slice(2) });
-}
-
-//#endregion
-export { runMain };