create-jilatax 0.0.3 → 0.0.5

package/dist/cli-DMT97_QW.cjs

@@ -0,0 +1,452 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _clack_prompts = require("@clack/prompts");
+_clack_prompts = __toESM(_clack_prompts, 1);
+let node_fs_promises = require("node:fs/promises");
+let node_process = require("node:process");
+let node_child_process = require("node:child_process");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_url = require("node:url");
+let jilatax = require("jilatax");
+//#region src/generator.ts
+const JILATAX_CLI_VERSION = "^0.0.8";
+const JILATAX_VERSION = "^0.0.5";
+const LYNX_QRCODE_PLUGIN_VERSION = "^0.4.4";
+const LYNX_REACT_VERSION = "^0.116.2";
+const LYNX_TYPES_VERSION = "^3.7.0";
+const REACT_PLUGIN_VERSION = "^0.12.7";
+const RSPEEDY_VERSION = "^0.13.3";
+const TEXT_TEMPLATE_FILES = /* @__PURE__ */ new Set([
+	"README.md.tmpl",
+	"android/settings.gradle.kts.tmpl",
+	"src/App.tsx.tmpl"
+]);
+async function createProject(options) {
+	const projectDirectory = node_path.default.resolve(options.targetDirectory);
+	const projectName = normalizeProjectName(node_path.default.basename(projectDirectory));
+	const displayName = normalizeDisplayName(options.displayName ?? titleCase$1(projectName));
+	const packageId = validatePackageId(options.packageId ?? defaultPackageId(projectName));
+	const config = createInitialConfig(displayName, projectName, packageId);
+	await assertTargetDoesNotExist(projectDirectory);
+	const parentDirectory = node_path.default.dirname(projectDirectory);
+	await (0, node_fs_promises.mkdir)(parentDirectory, { recursive: true });
+	const stagingDirectory = await (0, node_fs_promises.mkdtemp)(node_path.default.join(parentDirectory, `.${projectName}-`));
+	try {
+		await renderTemplate(stagingDirectory, {
+			displayName,
+			projectName
+		});
+		await writeGeneratedMetadata(stagingDirectory, config, projectName);
+		await (0, node_fs_promises.rename)(stagingDirectory, projectDirectory);
+	} catch (error) {
+		await (0, node_fs_promises.rm)(stagingDirectory, {
+			force: true,
+			recursive: true
+		});
+		throw error;
+	}
+	const shouldInstall = options.install === true;
+	if (shouldInstall) await (options.installer ?? installWithBun)(projectDirectory);
+	return {
+		displayName,
+		installed: shouldInstall,
+		packageId,
+		projectDirectory,
+		projectName
+	};
+}
+function normalizeProjectName(value) {
+	const projectName = value.trim().toLowerCase();
+	if (!/^[a-z0-9][a-z0-9._-]*$/u.test(projectName) || projectName.length > 214) throw new Error("Project directory name must start with a letter or number and contain only lowercase letters, numbers, dots, hyphens, or underscores.");
+	return projectName;
+}
+function normalizeDisplayName(value) {
+	const displayName = value.trim().replace(/\s+/gu, " ");
+	if (displayName.length === 0 || displayName.length > 80) throw new Error("Application name must contain between 1 and 80 characters.");
+	return displayName;
+}
+function defaultPackageId(projectName) {
+	return `com.example.${projectName.replace(/[^a-z0-9_]+/gu, "_").replace(/^[^a-z]+/u, "").replace(/_+$/gu, "") || "app"}`;
+}
+function validatePackageId(value) {
+	const packageId = value.trim();
+	(0, jilatax.parseAppConfig)({ jilatax: {
+		android: { package: packageId },
+		name: "Package validation"
+	} });
+	return packageId;
+}
+async function renderTemplate(targetRoot, values) {
+	await copyTemplateDirectory((0, node_url.fileURLToPath)(new URL("../template", require("url").pathToFileURL(__filename).href)), targetRoot, "", values);
+}
+async function copyTemplateDirectory(templateRoot, targetRoot, relativeDirectory, values) {
+	const entries = await (0, node_fs_promises.readdir)(node_path.default.join(templateRoot, relativeDirectory), { withFileTypes: true });
+	for (const entry of entries) {
+		const relativeSource = node_path.default.join(relativeDirectory, entry.name);
+		const normalizedSource = relativeSource.split(node_path.default.sep).join("/");
+		const sourcePath = node_path.default.join(templateRoot, relativeSource);
+		if (entry.isSymbolicLink() || !entry.isDirectory() && !entry.isFile()) throw new Error(`Unsupported template entry: ${normalizedSource}`);
+		if (entry.isDirectory()) {
+			await copyTemplateDirectory(templateRoot, targetRoot, relativeSource, values);
+			continue;
+		}
+		const outputRelative = templateOutputPath(normalizedSource);
+		const outputPath = node_path.default.join(targetRoot, ...outputRelative.split("/"));
+		await (0, node_fs_promises.mkdir)(node_path.default.dirname(outputPath), { recursive: true });
+		if (normalizedSource.endsWith("gradle-wrapper.jar.base64")) {
+			const encoded = (await (0, node_fs_promises.readFile)(sourcePath, "utf8")).replace(/\s+/gu, "");
+			await (0, node_fs_promises.writeFile)(outputPath, Buffer.from(encoded, "base64"));
+			continue;
+		}
+		if (TEXT_TEMPLATE_FILES.has(normalizedSource)) {
+			await (0, node_fs_promises.writeFile)(outputPath, renderTextTemplate(await (0, node_fs_promises.readFile)(sourcePath, "utf8"), values), "utf8");
+			continue;
+		}
+		if (normalizedSource.endsWith(".tmpl")) throw new Error(`Unregistered text template: ${normalizedSource}`);
+		await (0, node_fs_promises.copyFile)(sourcePath, outputPath);
+	}
+}
+function templateOutputPath(relativeSource) {
+	if (relativeSource === "gitignore") return ".gitignore";
+	if (relativeSource.endsWith("gradle-wrapper.jar.base64")) return relativeSource.slice(0, -7);
+	return relativeSource.endsWith(".tmpl") ? relativeSource.slice(0, -5) : relativeSource;
+}
+function renderTextTemplate(source, values) {
+	const replacements = /* @__PURE__ */ new Map([
+		["{{displayNameJson}}", JSON.stringify(values.displayName)],
+		["{{projectName}}", values.projectName],
+		["{{projectNameJson}}", JSON.stringify(values.projectName)]
+	]);
+	let rendered = source;
+	for (const [token, replacement] of replacements) rendered = rendered.replaceAll(token, replacement);
+	const unresolved = rendered.match(/\{\{[A-Za-z][A-Za-z0-9]*\}\}/u);
+	if (unresolved !== null) throw new Error(`Unresolved template token: ${unresolved[0]}`);
+	return rendered;
+}
+async function writeGeneratedMetadata(projectRoot, config, projectName) {
+	const packageJson = {
+		name: projectName,
+		version: config.jilatax.version,
+		private: true,
+		type: "module",
+		packageManager: "bun@1.3.4",
+		engines: { node: ">=22.18.0" },
+		scripts: {
+			dev: "rspeedy dev",
+			build: "rspeedy build",
+			typecheck: "tsc -b",
+			"run:android": "jilatax run:android",
+			"create:aab": "jilatax create:aab"
+		},
+		dependencies: {
+			"@lynx-js/react": LYNX_REACT_VERSION,
+			jilatax: JILATAX_VERSION
+		},
+		devDependencies: {
+			"@jilatax/cli": JILATAX_CLI_VERSION,
+			"@lynx-js/qrcode-rsbuild-plugin": LYNX_QRCODE_PLUGIN_VERSION,
+			"@lynx-js/react-rsbuild-plugin": REACT_PLUGIN_VERSION,
+			"@lynx-js/rspeedy": RSPEEDY_VERSION,
+			"@lynx-js/types": LYNX_TYPES_VERSION,
+			"@types/node": "^22.20.1",
+			"@types/react": "^18.3.20",
+			typescript: "~5.9.3"
+		}
+	};
+	await (0, node_fs_promises.writeFile)(node_path.default.join(projectRoot, "package.json"), `${JSON.stringify(packageJson, null, 2)}\n`, "utf8");
+	await (0, node_fs_promises.writeFile)(node_path.default.join(projectRoot, "app.json"), `${JSON.stringify(config, null, 2)}\n`, "utf8");
+	await (0, node_fs_promises.writeFile)(node_path.default.join(projectRoot, "android", "jilatax.properties"), (0, jilatax.serializeAndroidProjectConfig)(config), "utf8");
+	if (process.platform !== "win32") await (0, node_fs_promises.chmod)(node_path.default.join(projectRoot, "android", "gradlew"), 493);
+}
+function createInitialConfig(displayName, projectName, packageId) {
+	const slug = projectName.replace(/[._-]+/gu, "-").replace(/^-|-$/gu, "");
+	const schemeBase = projectName.replace(/[^a-z0-9+.-]+/gu, "-").replace(/^[^a-z]+/u, "");
+	return (0, jilatax.parseAppConfig)({
+		$schema: "./node_modules/jilatax/schema/app.schema.json",
+		jilatax: {
+			android: {
+				package: packageId,
+				predictiveBackGestureEnabled: false,
+				versionCode: 1
+			},
+			name: displayName,
+			orientation: "portrait",
+			scheme: schemeBase || "jilatax-app",
+			slug,
+			splash: { backgroundColor: "#0F172A" },
+			userInterfaceStyle: "automatic",
+			version: "1.0.0"
+		}
+	});
+}
+async function assertTargetDoesNotExist(target) {
+	try {
+		await (0, node_fs_promises.lstat)(target);
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+	throw new Error(`Target directory already exists: ${target}`);
+}
+function titleCase$1(value) {
+	return value.split(/[-_.\s]+/u).filter(Boolean).map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join(" ");
+}
+function installWithBun(projectDirectory) {
+	return new Promise((resolveInstall, rejectInstall) => {
+		const child = (0, node_child_process.spawn)("bun", ["install"], {
+			cwd: projectDirectory,
+			env: process.env,
+			stdio: "inherit",
+			windowsHide: true
+		});
+		child.once("error", rejectInstall);
+		child.once("close", (code) => {
+			if (code === 0) {
+				resolveInstall();
+				return;
+			}
+			rejectInstall(/* @__PURE__ */ new Error(`bun install failed with exit code ${code ?? 1}.`));
+		});
+	});
+}
+//#endregion
+//#region src/cli.ts
+var PromptCancelledError = class extends Error {};
+async function runCreateCli(args = process.argv.slice(2), services = {}) {
+	const log = services.log ?? console.log;
+	const warn = services.warn ?? console.error;
+	try {
+		const parsed = parseArgs(args);
+		if (parsed.showHelp) {
+			log(createHelpText());
+			return 0;
+		}
+		if (parsed.showVersion) {
+			log(await readCreatorVersion());
+			return 0;
+		}
+		const options = services.interactive ?? (node_process.stdin.isTTY && node_process.stdout.isTTY) ? await promptForOptions(parsed) : nonInteractiveOptions(parsed);
+		printResult(await (services.create ?? createProject)({
+			displayName: options.displayName,
+			install: options.install,
+			packageId: options.packageId,
+			targetDirectory: options.targetDirectory
+		}), log);
+		return 0;
+	} catch (error) {
+		if (error instanceof PromptCancelledError) return 0;
+		warn(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
+}
+function createHelpText() {
+	return `Create an Android-first Jilatax application.
+
+Usage:
+  create-jilatax [directory] [options]
+
+Options:
+  --name <display-name>   Human-readable application name
+  --package-id <id>       Android application ID
+  --install               Install dependencies with Bun
+  --skip-install          Generate without installing dependencies
+  -h, --help              Show this help
+  -V, --version           Show the installed creator version`;
+}
+function parseArgs(args) {
+	let displayName;
+	let install;
+	let packageId;
+	let showHelp = false;
+	let showVersion = false;
+	let targetDirectory;
+	for (let index = 0; index < args.length; index += 1) {
+		const argument = args[index];
+		if (argument === void 0) continue;
+		if (argument === "--install") install = true;
+		else if (argument === "--skip-install" || argument === "--no-install") install = false;
+		else if (argument === "--name") {
+			displayName = readOptionValue(args, index, argument);
+			index += 1;
+		} else if (argument.startsWith("--name=")) displayName = readInlineValue(argument, "--name");
+		else if (argument === "--package-id") {
+			packageId = readOptionValue(args, index, argument);
+			index += 1;
+		} else if (argument.startsWith("--package-id=")) packageId = readInlineValue(argument, "--package-id");
+		else if (argument === "--help" || argument === "-h") showHelp = true;
+		else if (argument === "--version" || argument === "-V") showVersion = true;
+		else if (argument.startsWith("-")) throw new Error(`Unknown option: ${argument}`);
+		else if (targetDirectory === void 0) targetDirectory = argument;
+		else throw new Error(`Unexpected argument: ${argument}`);
+	}
+	return {
+		...displayName === void 0 ? {} : { displayName },
+		...install === void 0 ? {} : { install },
+		...packageId === void 0 ? {} : { packageId },
+		showHelp,
+		showVersion,
+		...targetDirectory === void 0 ? {} : { targetDirectory }
+	};
+}
+async function promptForOptions(options) {
+	_clack_prompts.intro("Jilatax · Android-first Lynx application");
+	const targetDirectory = options.targetDirectory ?? unwrapPrompt(await _clack_prompts.text({
+		message: "Where should the project be created?",
+		placeholder: "./my-jilatax-app",
+		validate(value) {
+			try {
+				normalizeProjectNameFromDirectory(value ?? "");
+			} catch (error) {
+				return validationMessage(error);
+			}
+		}
+	}));
+	const projectName = normalizeProjectNameFromDirectory(targetDirectory);
+	const displayName = options.displayName ?? unwrapPrompt(await _clack_prompts.text({
+		initialValue: titleCase(projectName),
+		message: "Application name",
+		validate(value) {
+			try {
+				normalizeDisplayName(value ?? "");
+			} catch (error) {
+				return validationMessage(error);
+			}
+		}
+	}));
+	const packageId = options.packageId ?? unwrapPrompt(await _clack_prompts.text({
+		initialValue: defaultPackageId(projectName),
+		message: "Android application ID",
+		validate(value) {
+			try {
+				validatePackageId(value ?? "");
+			} catch (error) {
+				return validationMessage(error);
+			}
+		}
+	}));
+	const install = options.install ?? unwrapPrompt(await _clack_prompts.confirm({
+		initialValue: true,
+		message: "Install dependencies with Bun?"
+	}));
+	return {
+		displayName: normalizeDisplayName(displayName),
+		install,
+		packageId: validatePackageId(packageId),
+		targetDirectory
+	};
+}
+function nonInteractiveOptions(options) {
+	if (options.targetDirectory === void 0) throw new Error("Project directory is required in a non-interactive terminal.");
+	const projectName = normalizeProjectNameFromDirectory(options.targetDirectory);
+	return {
+		displayName: normalizeDisplayName(options.displayName ?? titleCase(projectName)),
+		install: options.install ?? false,
+		packageId: validatePackageId(options.packageId ?? defaultPackageId(projectName)),
+		targetDirectory: options.targetDirectory
+	};
+}
+function normalizeProjectNameFromDirectory(directory) {
+	return normalizeProjectName(directory.trim().replace(/[\\/]+$/gu, "").split(/[\\/]/u).at(-1) ?? "");
+}
+function unwrapPrompt(value) {
+	if (_clack_prompts.isCancel(value)) {
+		_clack_prompts.cancel("Project creation cancelled.");
+		throw new PromptCancelledError();
+	}
+	return value;
+}
+function validationMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function readOptionValue(args, index, option) {
+	const value = args[index + 1];
+	if (value === void 0 || value.startsWith("-") || value.trim().length === 0) throw new Error(`${option} requires a value.`);
+	return value.trim();
+}
+function readInlineValue(argument, option) {
+	const value = argument.slice(`${option}=`.length).trim();
+	if (value.length === 0) throw new Error(`${option} requires a value.`);
+	return value;
+}
+function titleCase(value) {
+	return value.split(/[-_.\s]+/u).filter(Boolean).map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join(" ");
+}
+function printResult(result, log) {
+	const installStep = result.installed ? "" : "  bun install\n";
+	log(`Created ${result.displayName} in ${result.projectDirectory}.
+
+Next steps:
+  cd ${JSON.stringify(result.projectDirectory)}
+${installStep}  bun run run:android
+
+Release bundle:
+  bun run create:aab`);
+}
+async function readCreatorVersion() {
+	const packageJson = JSON.parse(await (0, node_fs_promises.readFile)(new URL("../package.json", require("url").pathToFileURL(__filename).href), "utf8"));
+	return typeof packageJson.version === "string" ? packageJson.version : "unknown";
+}
+//#endregion
+Object.defineProperty(exports, "createHelpText", {
+	enumerable: true,
+	get: function() {
+		return createHelpText;
+	}
+});
+Object.defineProperty(exports, "createProject", {
+	enumerable: true,
+	get: function() {
+		return createProject;
+	}
+});
+Object.defineProperty(exports, "defaultPackageId", {
+	enumerable: true,
+	get: function() {
+		return defaultPackageId;
+	}
+});
+Object.defineProperty(exports, "normalizeDisplayName", {
+	enumerable: true,
+	get: function() {
+		return normalizeDisplayName;
+	}
+});
+Object.defineProperty(exports, "normalizeProjectName", {
+	enumerable: true,
+	get: function() {
+		return normalizeProjectName;
+	}
+});
+Object.defineProperty(exports, "runCreateCli", {
+	enumerable: true,
+	get: function() {
+		return runCreateCli;
+	}
+});
+Object.defineProperty(exports, "validatePackageId", {
+	enumerable: true,
+	get: function() {
+		return validatePackageId;
+	}
+});

package/dist/index.cjs

@@ -1,7 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/index.ts
-function hello(name) {
-	return `Hello, ${name}!`;
-}
-//#endregion
-exports.hello = hello;
+const require_cli = require("./cli-DMT97_QW.cjs");
+exports.createHelpText = require_cli.createHelpText;
+exports.createProject = require_cli.createProject;
+exports.defaultPackageId = require_cli.defaultPackageId;
+exports.normalizeDisplayName = require_cli.normalizeDisplayName;
+exports.normalizeProjectName = require_cli.normalizeProjectName;
+exports.runCreateCli = require_cli.runCreateCli;
+exports.validatePackageId = require_cli.validatePackageId;

package/dist/index.d.cts

@@ -1,4 +1,33 @@
-//#region src/index.d.ts
-declare function hello(name: string): string;
+//#region src/generator.d.ts
+interface CreateProjectOptions {
+  readonly displayName?: string;
+  readonly install?: boolean;
+  readonly installer?: ProjectInstaller;
+  readonly packageId?: string;
+  readonly targetDirectory: string;
+}
+interface CreateProjectResult {
+  readonly displayName: string;
+  readonly installed: boolean;
+  readonly packageId: string;
+  readonly projectDirectory: string;
+  readonly projectName: string;
+}
+type ProjectInstaller = (projectDirectory: string) => Promise<void>;
+declare function createProject(options: CreateProjectOptions): Promise<CreateProjectResult>;
+declare function normalizeProjectName(value: string): string;
+declare function normalizeDisplayName(value: string): string;
+declare function defaultPackageId(projectName: string): string;
+declare function validatePackageId(value: string): string;
 //#endregion
-export { hello };
+//#region src/cli.d.ts
+interface CreateCliServices {
+  readonly create?: typeof createProject;
+  readonly interactive?: boolean;
+  readonly log?: (message: string) => void;
+  readonly warn?: (message: string) => void;
+}
+declare function runCreateCli(args?: readonly string[], services?: CreateCliServices): Promise<number>;
+declare function createHelpText(): string;
+//#endregion
+export { type CreateCliServices, type CreateProjectOptions, type CreateProjectResult, type ProjectInstaller, createHelpText, createProject, defaultPackageId, normalizeDisplayName, normalizeProjectName, runCreateCli, validatePackageId };

package/dist/index.d.ts

@@ -1,4 +1,33 @@
-//#region src/index.d.ts
-declare function hello(name: string): string;
+//#region src/generator.d.ts
+interface CreateProjectOptions {
+  readonly displayName?: string;
+  readonly install?: boolean;
+  readonly installer?: ProjectInstaller;
+  readonly packageId?: string;
+  readonly targetDirectory: string;
+}
+interface CreateProjectResult {
+  readonly displayName: string;
+  readonly installed: boolean;
+  readonly packageId: string;
+  readonly projectDirectory: string;
+  readonly projectName: string;
+}
+type ProjectInstaller = (projectDirectory: string) => Promise<void>;
+declare function createProject(options: CreateProjectOptions): Promise<CreateProjectResult>;
+declare function normalizeProjectName(value: string): string;
+declare function normalizeDisplayName(value: string): string;
+declare function defaultPackageId(projectName: string): string;
+declare function validatePackageId(value: string): string;
 //#endregion
-export { hello };
+//#region src/cli.d.ts
+interface CreateCliServices {
+  readonly create?: typeof createProject;
+  readonly interactive?: boolean;
+  readonly log?: (message: string) => void;
+  readonly warn?: (message: string) => void;
+}
+declare function runCreateCli(args?: readonly string[], services?: CreateCliServices): Promise<number>;
+declare function createHelpText(): string;
+//#endregion
+export { type CreateCliServices, type CreateProjectOptions, type CreateProjectResult, type ProjectInstaller, createHelpText, createProject, defaultPackageId, normalizeDisplayName, normalizeProjectName, runCreateCli, validatePackageId };

package/dist/index.js

@@ -1,6 +1,2 @@
-//#region src/index.ts
-function hello(name) {
-	return `Hello, ${name}!`;
-}
-//#endregion
-export { hello };
+import { a as normalizeDisplayName, i as defaultPackageId, n as runCreateCli, o as normalizeProjectName, r as createProject, s as validatePackageId, t as createHelpText } from "./cli-B8DIbCrH.js";
+export { createHelpText, createProject, defaultPackageId, normalizeDisplayName, normalizeProjectName, runCreateCli, validatePackageId };

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "create-jilatax",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "packageManager": "bun@1.3.4",
-  "description": "A minimal TypeScript library package with ESM, CommonJS, and declaration outputs.",
+  "description": "Create an Android-first Jilatax application for Lynx and Rspeedy.",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "bin": {
+    "create-jilatax": "./dist/bin.js"
+  },
   "exports": {
     ".": {
       "import": {
@@ -19,10 +22,10 @@
       }
     }
   },
-  "files": ["dist"],
-  "sideEffects": false,
+  "files": ["dist", "template", "THIRD_PARTY_NOTICES.md"],
+  "sideEffects": ["./dist/bin.js"],
 
-  "keywords": ["typescript", "esm", "commonjs"],
+  "keywords": ["android", "creator", "jilatax", "lynx", "rspeedy"],
   "author": "Gohit X (bastndev)",
   "license": "MIT",
   "homepage": "https://jilatax.dev/jilatax",
@@ -40,6 +43,11 @@
     "node": ">=22.18.0"
   },
 
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "jilatax": "^0.0.5"
+  },
+
   "devDependencies": {
     "@arethetypeswrong/core": "^0.18.5",
     "@types/node": "^22.20.1",

package/template/README.md.tmpl

@@ -0,0 +1,34 @@
+# {{projectName}}
+
+Android-first Lynx application created with Jilatax.
+
+## Development
+
+```bash
+bun install
+bun run run:android
+```
+
+The Android command starts Rspeedy, builds and installs the debug APK, verifies
+the ADB reverse tunnel, and launches the app once.
+
+To run only the Lynx development server:
+
+```bash
+bun run dev
+```
+
+When the build is ready, scan the printed QR code with the Lynx application on
+the same network to preview the bundle on a device.
+
+## Android App Bundle
+
+```bash
+bun run create:aab
+```
+
+Configure `android/keystore.properties` from the included example before a
+Play Store release. Never commit signing credentials.
+
+Application metadata lives in `app.json`. Android is the only supported native
+platform in this phase.