@kimesh/cli 0.1.1 → 0.2.0-nightly.20260120083917

package/dist/_shared-CEwpPT2B.js

@@ -0,0 +1,84 @@
+//#region src/commands/_shared.ts
+/**
+* Shared arguments used across multiple commands
+*/
+const sharedArgs = {
+	root: {
+		type: "string",
+		alias: "r",
+		description: "Project root directory"
+	},
+	config: {
+		type: "string",
+		alias: "c",
+		description: "Config file path"
+	},
+	logLevel: {
+		type: "string",
+		description: "Log level (silent, info, verbose)"
+	}
+};
+/**
+* Dev command specific arguments
+*/
+const devArgs = {
+	...sharedArgs,
+	port: {
+		type: "string",
+		alias: "p",
+		description: "Server port",
+		default: "3000"
+	},
+	host: {
+		type: "string",
+		alias: "h",
+		description: "Server host"
+	},
+	open: {
+		type: "boolean",
+		alias: "o",
+		description: "Open browser on start",
+		default: false
+	},
+	layers: {
+		type: "string",
+		alias: "l",
+		description: "Comma-separated list of layers or all/none"
+	},
+	"exclude-layers": {
+		type: "string",
+		alias: "x",
+		description: "Comma-separated list of layers to exclude"
+	}
+};
+/**
+* Build command specific arguments
+*/
+const buildArgs = {
+	...sharedArgs,
+	minify: {
+		type: "boolean",
+		description: "Minify output",
+		default: true
+	},
+	sourcemap: {
+		type: "boolean",
+		description: "Generate sourcemaps",
+		default: false
+	}
+};
+/**
+* Prepare command specific arguments
+*/
+const prepareArgs = {
+	...sharedArgs,
+	verbose: {
+		type: "boolean",
+		alias: "v",
+		description: "Enable verbose logging",
+		default: false
+	}
+};
+
+//#endregion
+export { buildArgs, devArgs, prepareArgs, sharedArgs };

package/dist/build-Ce4Dm8mI.js

@@ -0,0 +1,34 @@
+import { loadKit } from "./kit-BcEYldTS.js";
+import { buildArgs } from "./_shared-CEwpPT2B.js";
+import { defineCommand } from "citty";
+import consola from "consola";
+import { resolve } from "node:path";
+
+//#region src/commands/build.ts
+var build_default = defineCommand({
+	meta: {
+		name: "build",
+		description: "Build for production"
+	},
+	args: buildArgs,
+	async run({ args }) {
+		const root = resolve(args.root || process.cwd());
+		consola.info(`Building for production...`);
+		const kit = await loadKit(root);
+		const { loadConfig, kimeshPlugin } = kit;
+		const kmConfig = await loadConfig({
+			root,
+			configFile: args.config
+		});
+		const { build } = await import("vite");
+		await build({
+			root,
+			configFile: false,
+			plugins: [kimeshPlugin({ config: kmConfig })]
+		});
+		consola.success(`Build complete!`);
+	}
+});
+
+//#endregion
+export { build_default as default };

package/dist/commands/init.d.ts

@@ -0,0 +1,24 @@
+import * as citty1 from "citty";
+
+//#region src/commands/init.d.ts
+declare const _default: citty1.CommandDef<{
+  root: {
+    type: "string";
+    alias: string;
+    description: string;
+  };
+  force: {
+    type: "boolean";
+    alias: string;
+    description: string;
+    default: false;
+  };
+  typescript: {
+    type: "boolean";
+    alias: string;
+    description: string;
+    default: true;
+  };
+}>;
+//#endregion
+export { _default as default };

package/dist/commands/init.js

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

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

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