@junejs/cli 0.0.50 → 0.0.51-dev.1

package/dist/cli.d.ts

@@ -0,0 +1,10 @@
+//#region src/cli.d.ts
+type Parsed = {
+  verb: string;
+  positional: string[];
+  flags: Record<string, string | boolean>;
+};
+declare function parse(argv: string[]): Parsed;
+declare function run(argv: string[]): Promise<number | undefined>;
+//#endregion
+export { Parsed, parse, run };

package/dist/cli.js

@@ -0,0 +1,170 @@
+import { existsSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+//#region src/cli.ts
+function parse(argv) {
+	const [verb = "", ...rest] = argv;
+	const positional = [];
+	const flags = {};
+	for (let i = 0; i < rest.length; i++) {
+		const a = rest[i];
+		if (a.startsWith("--")) {
+			const key = a.slice(2);
+			const next = rest[i + 1];
+			if (next !== void 0 && !next.startsWith("--")) {
+				flags[key] = next;
+				i++;
+			} else flags[key] = true;
+		} else positional.push(a);
+	}
+	return {
+		verb,
+		positional,
+		flags
+	};
+}
+const HELP = `june — the agent-native React framework
+
+Usage: june <command> [dir] [options]
+
+Commands:
+  dev      Start the dev server                 --port <n> --no-watch
+  build    Build a workerd-ready bundle         --out <dir>
+  deploy   Build + deploy (workers/vercel)      --dry-run --prod --skip-migrate --allow-destructive
+  gen      Freeze content/schema                --check
+  db       Database tasks (db migrate, db types) --allow-destructive
+  info     Show routes + the agent surface
+  help     Show this help
+
+The app directory defaults to the current directory.
+`;
+function appRoot(positional) {
+	return positional[0] ? resolve(positional[0]) : process.cwd();
+}
+async function info(root) {
+	const { createApp, loadJuneConfig } = await import("@junejs/server");
+	const { resolveAgent } = await import("@junejs/core/config");
+	const { ACTION_REGISTRY } = await import("@junejs/core/agent");
+	const config = await loadJuneConfig(root);
+	const app = createApp({
+		appDir: join(root, "app"),
+		config
+	});
+	await app.warmup();
+	const routes = await app.routePaths();
+	const agent = resolveAgent(config.agent);
+	const tools = [...ACTION_REGISTRY.values()].filter((a) => a.description).map((a) => a.id);
+	console.log(`June app: ${config.site?.name ?? "(unnamed)"}`);
+	console.log(`\nRoutes (${routes.length}):`);
+	for (const r of routes) console.log(`  ${r}`);
+	if (agent.enabled) {
+		console.log(`\nAgent surface:`);
+		if (agent.discovery) console.log(`  discovery  /llms.txt · /sitemap.xml · /.well-known/api-catalog`);
+		if (agent.mcp) console.log(`  mcp        /mcp  (tools: ${tools.length ? tools.join(", ") : "none"})`);
+	} else console.log(`\nAgent surface: disabled`);
+	return 0;
+}
+async function run(argv) {
+	const { verb, positional, flags } = parse(argv);
+	const root = appRoot(positional);
+	switch (verb) {
+		case "dev": {
+			if (!existsSync(join(root, "app"))) {
+				console.error(`june dev: ${root} doesn't look like a June app (no app/ directory).`);
+				if (/^\d+$/.test(positional[0] ?? "")) console.error(`  to choose a port, use --port:  june dev --port ${positional[0]}  ·  npm run dev -- --port ${positional[0]}`);
+				return 1;
+			}
+			if (!process.env.JUNE_DEV_CHILD && !flags["no-watch"]) {
+				const { superviseDev } = await import("./watch-CeyzNVKv.js");
+				return superviseDev(root);
+			}
+			const { startDevServer } = await import("@junejs/server");
+			await startDevServer({
+				appDir: join(root, "app"),
+				port: flags.port ? Number(flags.port) : 3e3
+			});
+			return;
+		}
+		case "build": {
+			const { juneBuild } = await import("@junejs/server");
+			const r = await juneBuild(root, typeof flags.out === "string" ? { outDir: resolve(flags.out) } : {});
+			console.log(`built ${r.outFile}  (${r.routes.length} routes, ${r.dynamicRoutes.length} dynamic, ${r.prerendered.length} prerendered)`);
+			return 0;
+		}
+		case "deploy": {
+			const { juneDeploy } = await import("@junejs/server");
+			const r = await juneDeploy(root, {
+				dryRun: !!flags["dry-run"],
+				skipMigrate: !!flags["skip-migrate"],
+				allowDestructive: !!flags["allow-destructive"],
+				prod: !!flags["prod"]
+			});
+			console.log(r.url ? `deployed → ${r.url}` : r.dryRun ? "dry-run ok" : "deployed");
+			return 0;
+		}
+		case "gen": {
+			const { generateContent } = await import("@junejs/server");
+			const cols = await generateContent(root);
+			console.log(cols.length ? `generated content: ${cols.join(", ")}` : "no content/ collections");
+			const { generateMessages } = await import("./messages-DfAlYpfN.js");
+			const locales = await generateMessages(root);
+			if (locales) console.log(`generated messages: ${locales.join(", ")}`);
+			return 0;
+		}
+		case "db": {
+			const sub = positional[0];
+			const dbRoot = positional[1] ? resolve(positional[1]) : process.cwd();
+			if (sub === "migrate") {
+				const { loadJuneConfig, migrateApp, blockedMessage } = await import("@junejs/server");
+				const config = await loadJuneConfig(dbRoot);
+				if (!config.resources?.db) {
+					console.error("june db migrate: no `db` resource declared in june.config.ts.");
+					return 1;
+				}
+				const r = await migrateApp(dbRoot, config, { allowDestructive: !!flags["allow-destructive"] });
+				if (r?.applied.length) console.log(`migrated: ${r.applied.join(", ")}`);
+				else if (r && !r.blocked) console.log("migrations up to date");
+				if (r?.blocked) {
+					console.error(blockedMessage(r.blocked));
+					return 1;
+				}
+				return 0;
+			}
+			if (sub === "types") {
+				const { loadJuneConfig, typesApp } = await import("@junejs/server");
+				const config = await loadJuneConfig(dbRoot);
+				if (!config.resources?.db) {
+					console.error("june db types: no `db` resource declared in june.config.ts.");
+					return 1;
+				}
+				if (!config.dataLayer?.emitTypes) {
+					console.error("june db types: the configured dataLayer doesn't generate types (declare `dataLayer: junoDataLayer()` in june.config.ts).");
+					return 1;
+				}
+				const text = await typesApp(dbRoot, config);
+				if (text == null) {
+					console.log("nothing to generate");
+					return 0;
+				}
+				await writeFile(join(dbRoot, "db", "schema.d.ts"), text);
+				console.log("wrote db/schema.d.ts");
+				return 0;
+			}
+			console.error(`june db: unknown subcommand "${sub ?? ""}" (try: june db migrate | june db types)`);
+			return 1;
+		}
+		case "info": return info(root);
+		case "":
+		case "help":
+		case "--help":
+		case "-h":
+			console.log(HELP);
+			return 0;
+		default:
+			console.error(`june: unknown command "${verb}"\n`);
+			console.log(HELP);
+			return 1;
+	}
+}
+//#endregion
+export { parse, run };

package/dist/messages-DfAlYpfN.js

@@ -0,0 +1,26 @@
+import { existsSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+//#region src/messages.ts
+/** Generate `app/_messages.ts` from `messages/*.json`. Returns the locales, or
+*  null when there's no `messages/` dir or @junejs/i18n isn't installed. */
+async function generateMessages(root) {
+	const messagesDir = join(root, "messages");
+	if (!existsSync(messagesDir)) return null;
+	let codegen;
+	try {
+		codegen = await import(pathToFileURL(createRequire(resolve(root, "package.json")).resolve("@junejs/i18n/codegen")).href);
+	} catch {
+		console.warn("[june] messages/ found but @junejs/i18n is not installed — skipping (run: bun add @junejs/i18n)");
+		return null;
+	}
+	const { loadJuneConfig } = await import("@junejs/server");
+	const defaultLocale = (await loadJuneConfig(root)).i18n?.defaultLocale ?? "en";
+	const { code, locales } = codegen.generateMessagesModule(messagesDir, { defaultLocale });
+	await writeFile(join(root, "app", "_messages.ts"), code);
+	return locales;
+}
+//#endregion
+export { generateMessages };

package/dist/watch-CeyzNVKv.js

@@ -0,0 +1,97 @@
+import { existsSync, watch } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+import { spawn } from "node:child_process";
+//#region src/watch.ts
+const IGNORED_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	"dist",
+	".june"
+]);
+function ignoredPath(file) {
+	const parts = file.split(sep);
+	if (parts.some((p) => IGNORED_DIRS.has(p))) return true;
+	if (file.endsWith(".css")) return true;
+	return parts.length === 2 && parts[0] === "app" && (/^_content\.[^/]+$/.test(parts[1]) || parts[1].endsWith(".gen.ts"));
+}
+function superviseDev(root) {
+	let child;
+	let restarting = false;
+	const start = () => {
+		child = spawn(process.execPath, process.argv.slice(1), {
+			stdio: "inherit",
+			env: {
+				...process.env,
+				JUNE_DEV_CHILD: "1"
+			}
+		});
+		child.on("exit", (code) => {
+			if (restarting) return;
+			console.error(`[june] dev server exited (${code ?? "?"}) — waiting for changes`);
+			child = void 0;
+		});
+	};
+	const restart = async (file, contentChanged) => {
+		if (restarting) return;
+		restarting = true;
+		if (contentChanged) try {
+			const { generateContent } = await import("@junejs/server");
+			await generateContent(root);
+		} catch (err) {
+			console.error("[june] content regen failed:", err);
+		}
+		if (file.startsWith(`messages${sep}`)) try {
+			const { generateMessages } = await import("./messages-DfAlYpfN.js");
+			await generateMessages(root);
+		} catch (err) {
+			console.error("[june] messages regen failed:", err);
+		}
+		console.log(`[june] ${file} changed — restarting`);
+		const c = child;
+		if (!c || c.exitCode !== null || c.signalCode !== null) {
+			restarting = false;
+			start();
+			return;
+		}
+		c.once("exit", () => {
+			restarting = false;
+			start();
+		});
+		c.kill();
+	};
+	let pending;
+	let timer;
+	const schedule = (file, content) => {
+		pending = {
+			file,
+			content: content || (pending?.content ?? false)
+		};
+		clearTimeout(timer);
+		timer = setTimeout(() => void restart(pending.file, pending.content), 80);
+	};
+	watch(root, { recursive: true }, (_event, file) => {
+		if (!file || ignoredPath(file)) return;
+		schedule(file, file.startsWith(`content${sep}`));
+	});
+	(async () => {
+		try {
+			const { loadJuneConfig } = await import("@junejs/server");
+			const config = await loadJuneConfig(root);
+			for (const s of config.content?.sources ?? []) {
+				const dir = resolve(root, s.dir);
+				if (!existsSync(dir)) continue;
+				watch(dir, { recursive: true }, (_event, file) => {
+					if (!file || ignoredPath(file)) return;
+					schedule(relative(root, join(dir, file)), true);
+				});
+			}
+		} catch {}
+	})();
+	for (const sig of ["SIGINT", "SIGTERM"]) process.on(sig, () => {
+		child?.kill(sig);
+		process.exit(0);
+	});
+	start();
+}
+//#endregion
+export { superviseDev };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/cli",
-  "version": "0.0.50",
+  "version": "0.0.51-dev.1",
   "description": "The `june` CLI — dev / build / deploy / gen / info. A thin bin over @junejs/server.",
   "type": "module",
   "license": "MIT",
@@ -9,19 +9,26 @@
     "june": "./bin.mjs"
   },
   "exports": {
-    ".": "./src/cli.ts"
+    ".": {
+      "source": "./src/cli.ts",
+      "bun": "./src/cli.ts",
+      "types": "./dist/cli.d.ts",
+      "default": "./dist/cli.js"
+    }
   },
   "files": [
     "src",
-    "bin.mjs"
+    "bin.mjs",
+    "dist"
   ],
   "scripts": {
     "test": "bun test",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "build": "tsdown"
   },
   "dependencies": {
-    "@junejs/core": ">=0.0.48",
-    "@junejs/server": ">=0.0.51"
+    "@junejs/core": ">=0.1.0-dev.4",
+    "@junejs/server": ">=0.1.0-dev.5"
   },
   "repository": {
     "type": "git",