@tenkit/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Tenkit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,6 @@
+# @tenkit/cli
+
+Public Tenkit CLI implementation package.
+
+The package-manager create entrypoint is `create-tenkit`; this package owns parsing, prompts,
+create-flow orchestration, install and git convenience policy, and final output.

package/dist/index.d.mts

@@ -0,0 +1,9 @@
+//#region src/cli.d.ts
+type CliIo = {
+  stdout: Pick<NodeJS.WriteStream, 'write' | 'isTTY'>;
+  stderr: Pick<NodeJS.WriteStream, 'write'>;
+  stdin: Pick<NodeJS.ReadStream, 'isTTY'>;
+};
+declare function main(argv?: string[], io?: CliIo): Promise<number>;
+//#endregion
+export { main };

package/dist/index.mjs

@@ -0,0 +1,467 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import fs from "fs-extra";
+import { dirname, resolve } from "pathe";
+import { cancel, confirm, intro, isCancel, outro, select, text } from "@clack/prompts";
+import { Command } from "commander";
+import { SUPPORTED_PUBLIC_SETUP_SLUGS, formatSupportedGeneratedSetupTypes, generateProject, normalizeGeneratedSetupType, preflightWriteProject, writeProject } from "@tenkit/template-generator";
+import { spawn } from "node:child_process";
+//#region src/adapters/workspace.ts
+function isPackageJsonShape(value) {
+	return typeof value === "object" && value !== null;
+}
+async function findTenkitWorkspaceRoot(startUrl) {
+	let current = dirname(fileURLToPath(startUrl));
+	while (true) {
+		const packageJsonPath = resolve(current, "package.json");
+		if (await fs.pathExists(packageJsonPath)) {
+			const packageJson = await fs.readJson(packageJsonPath);
+			if (isPackageJsonShape(packageJson) && packageJson.name === "tenkit-workspace") return current;
+		}
+		const parent = dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function isDirectCliRun(entryUrl, argvEntry) {
+	if (!argvEntry) return false;
+	return resolveRealPath(fileURLToPath(entryUrl)) === resolveRealPath(argvEntry);
+}
+function resolveRealPath(path) {
+	try {
+		return fs.realpathSync(path);
+	} catch {
+		return resolve(path);
+	}
+}
+//#endregion
+//#region src/constants.ts
+const CLI_VERSION = "0.1.0";
+const DEFAULT_PROJECT_NAME = "tenkit-app";
+const DEFAULT_PUBLIC_SETUP_SLUG = "white-label";
+const PROMPT_CANCELLED = Symbol("prompt-cancelled");
+const SETUP_PROMPT_CHOICES = [
+	{
+		value: "white-label",
+		label: "White Label Apps"
+	},
+	{
+		value: "runtime-tenants",
+		label: "Runtime Tenant App"
+	},
+	{
+		value: "generic-standalone",
+		label: "Generic + Standalone Apps"
+	}
+];
+function supportedSetupValues() {
+	return SUPPORTED_PUBLIC_SETUP_SLUGS;
+}
+//#endregion
+//#region src/adapters/command-runner.ts
+function defaultRunCommand(command, args, cwd, options = {}) {
+	return new Promise((resolveCommand) => {
+		const child = spawn(command, [...args], {
+			cwd,
+			stdio: options.stdio ?? "inherit"
+		});
+		child.on("error", () => {
+			resolveCommand({
+				ok: false,
+				code: 1
+			});
+		});
+		child.on("close", (code) => {
+			resolveCommand({
+				ok: code === 0,
+				code: code ?? 1
+			});
+		});
+	});
+}
+//#endregion
+//#region src/errors.ts
+var CreateFlowCancelledError = class extends Error {
+	constructor() {
+		super("Create cancelled.");
+	}
+};
+//#endregion
+//#region src/adapters/git.ts
+async function isGitAvailable(runCommand, cwd) {
+	return (await runCommand("git", ["--version"], cwd, { stdio: "ignore" })).ok;
+}
+async function isInsideGitWorktree(runCommand, cwd) {
+	return (await runCommand("git", ["rev-parse", "--is-inside-work-tree"], cwd, { stdio: "ignore" })).ok;
+}
+async function resolveGitMode({ explicitGitMode, env, runCommand, targetDir }) {
+	if (explicitGitMode === false || explicitGitMode === "none") return {
+		mode: false,
+		skippedReason: "disabled"
+	};
+	if (!await isGitAvailable(runCommand, targetDir)) return {
+		mode: false,
+		skippedReason: "git-unavailable"
+	};
+	if (await isInsideGitWorktree(runCommand, targetDir) && explicitGitMode === void 0) {
+		if (!env.isInteractive || env.isCi) return {
+			mode: false,
+			skippedReason: "nested-worktree"
+		};
+		const answer = await env.prompts.confirm({
+			message: "Initialize a nested git repository?",
+			initialValue: false
+		});
+		if (answer === PROMPT_CANCELLED) throw new CreateFlowCancelledError();
+		if (!answer) return {
+			mode: false,
+			skippedReason: "nested-worktree"
+		};
+	}
+	if (explicitGitMode === "init") return { mode: "init" };
+	return { mode: "commit" };
+}
+async function prepareInitialGitSetup({ explicitGitMode, env, runCommand, probeDir }) {
+	const gitPlan = await resolveGitMode({
+		explicitGitMode,
+		env,
+		runCommand,
+		targetDir: probeDir
+	});
+	return { async run(targetDir) {
+		if (!gitPlan.mode) return {
+			gitInitialized: false,
+			gitCommitted: false,
+			gitSkippedReason: gitPlan.skippedReason,
+			gitFailed: false
+		};
+		const initResult = await runCommand("git", ["init"], targetDir);
+		const gitInitialized = initResult.ok;
+		if (!initResult.ok) return {
+			gitInitialized,
+			gitCommitted: false,
+			gitFailed: true
+		};
+		if (gitPlan.mode === "init") return {
+			gitInitialized,
+			gitCommitted: false,
+			gitFailed: false
+		};
+		const commitResult = (await runCommand("git", ["add", "--all"], targetDir)).ok ? await runCommand("git", [
+			"commit",
+			"-m",
+			"Initial commit"
+		], targetDir) : {
+			ok: false,
+			code: 1
+		};
+		return {
+			gitInitialized,
+			gitCommitted: commitResult.ok,
+			gitFailed: !commitResult.ok
+		};
+	} };
+}
+//#endregion
+//#region src/create/create-messages.ts
+function logFinalOutput(result, output) {
+	const projectShellArg = formatShellArg(result.projectName);
+	output.log("");
+	output.log(result.status === "dry-run" ? "Tenkit create plan is valid." : "Your Tenkit project is ready.");
+	output.log("");
+	output.log("Next steps:");
+	output.log(`- cd ${projectShellArg}`);
+	if (result.installFailed || !result.installed) output.log("- pnpm install");
+	output.log("- pnpm run android");
+	output.log("- pnpm run ios");
+	output.log("- pnpm run web");
+	if (result.installFailed) {
+		output.log("");
+		output.log("Dependency installation failed. Run pnpm install in the generated project.");
+	}
+	if (result.gitSkippedReason === "git-unavailable") {
+		output.log("");
+		output.log("Git was not available. Run git init when ready.");
+	} else if (result.gitSkippedReason === "nested-worktree") {
+		output.log("");
+		output.log("Git initialization was skipped because the project is inside an existing git worktree.");
+	} else if (result.gitFailed) {
+		output.log("");
+		output.log("Git setup did not complete. Run git init, git add --all, and git commit -m \"Initial commit\" when ready.");
+	}
+}
+function formatShellArg(value) {
+	if (/^[A-Za-z0-9._/-]+$/.test(value)) return value;
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+//#endregion
+//#region src/create/validation.ts
+function isPathSeparatorPresent(value) {
+	return value.includes("/") || value.includes("\\");
+}
+function validateProjectName(value) {
+	const projectName = value.trim();
+	if (projectName.length === 0) throw new Error("Project name is required.");
+	if (projectName === "." || projectName === "..") throw new Error("Project name must be a child folder name.");
+	if (isPathSeparatorPresent(projectName)) throw new Error("Project name must not contain path separators.");
+	if (/[\0-\x1F<>:"|?*]/.test(projectName)) throw new Error("Project name contains characters that are unsafe for a project folder.");
+	return projectName;
+}
+function slugifyPackageName(projectName) {
+	return projectName.trim().toLowerCase().replace(/['"]/g, "").replace(/[^a-z0-9._-]+/g, "-").replace(/^[._-]+|[._-]+$/g, "").replace(/-{2,}/g, "-");
+}
+function validatePackageName(value) {
+	const packageName = value.trim();
+	if (packageName.length === 0) throw new Error("Package name is required.");
+	if (packageName.length > 214) throw new Error("Package name must be 214 characters or fewer.");
+	if (packageName !== packageName.toLowerCase()) throw new Error("Package name must be lowercase.");
+	if (isPathSeparatorPresent(packageName)) throw new Error("Package name must not contain path separators.");
+	if (packageName.startsWith(".") || packageName.startsWith("_")) throw new Error("Package name must not start with \".\" or \"_\".");
+	if (!/^[a-z0-9][a-z0-9._-]*$/.test(packageName)) throw new Error("Package name must contain only lowercase letters, numbers, \".\", \"_\", and \"-\".");
+	return packageName;
+}
+function derivePackageName(projectName) {
+	return validatePackageName(slugifyPackageName(projectName));
+}
+function normalizeSetupInput(setup, setupType) {
+	if (setup !== void 0 && setupType !== void 0 && setup !== setupType) throw new Error("Use either --setup or --setup-type, not both with different values.");
+	const selectedSetup = setup ?? setupType ?? "white-label";
+	try {
+		return normalizeGeneratedSetupType(selectedSetup);
+	} catch {
+		throw new Error(`Unsupported Setup Type ${JSON.stringify(selectedSetup)}. Expected ${formatSupportedGeneratedSetupTypes()}.`);
+	}
+}
+function parseGitMode(value) {
+	if (value === false) return false;
+	if (value === void 0) return;
+	if (value === "init" || value === "commit" || value === "none") return value;
+	throw new Error("Git mode must be one of: init, commit, none.");
+}
+//#endregion
+//#region src/create/resolve-create-options.ts
+async function readProjectName(options, env) {
+	if (options.name !== void 0) return validateProjectName(options.name);
+	if (options.yes) return DEFAULT_PROJECT_NAME;
+	if (!env.isInteractive) throw new Error("Missing --name. Pass --name or use --yes to accept the default.");
+	const answer = await env.prompts.text({
+		message: "Project name",
+		initialValue: DEFAULT_PROJECT_NAME,
+		validate(value) {
+			try {
+				validateProjectName(value ?? "");
+				return;
+			} catch (error) {
+				return error instanceof Error ? error.message : String(error);
+			}
+		}
+	});
+	if (answer === PROMPT_CANCELLED) throw new CreateFlowCancelledError();
+	return validateProjectName(answer);
+}
+async function readSetupType(options, env) {
+	if (options.setup !== void 0 || options.setupType !== void 0) return normalizeSetupInput(options.setup, options.setupType);
+	if (options.yes) return normalizeGeneratedSetupType(DEFAULT_PUBLIC_SETUP_SLUG);
+	if (!env.isInteractive) throw new Error("Missing --setup. Pass --setup or use --yes to accept the default.");
+	const answer = await env.prompts.select({
+		message: "Setup Type",
+		initialValue: DEFAULT_PUBLIC_SETUP_SLUG,
+		options: SETUP_PROMPT_CHOICES
+	});
+	if (answer === PROMPT_CANCELLED) throw new CreateFlowCancelledError();
+	return normalizeGeneratedSetupType(answer);
+}
+async function assertTargetIsSafe(targetDir) {
+	if (!await fs.pathExists(targetDir)) return;
+	if (!(await fs.stat(targetDir)).isDirectory()) throw new Error(`Generated project target ${targetDir} exists but is not a directory.`);
+	if ((await fs.readdir(targetDir)).length > 0) throw new Error(`Generated project target ${targetDir} already exists and is not empty.`);
+}
+async function resolveCreateOptions(options, env) {
+	const projectName = await readProjectName(options, env);
+	const setupType = await readSetupType(options, env);
+	const packageName = options.packageName !== void 0 ? validatePackageName(options.packageName) : derivePackageName(projectName);
+	const targetDir = resolve(env.cwd, projectName);
+	await assertTargetIsSafe(targetDir);
+	return {
+		projectName,
+		packageName,
+		setupType,
+		targetDir,
+		install: options.install !== false,
+		git: parseGitMode(options.git),
+		dryRun: options.dryRun === true
+	};
+}
+//#endregion
+//#region src/create/run-create.ts
+async function runCreateFlow(options, env) {
+	const resolvedOptions = await resolveCreateOptions(options, env);
+	const runCommand = env.runCommand ?? defaultRunCommand;
+	const generate = env.generate ?? generateProject;
+	const write = env.write ?? ((writeOptions) => writeProject({
+		...writeOptions,
+		overwrite: "never"
+	}));
+	const tree = generate({
+		setupType: resolvedOptions.setupType,
+		projectName: resolvedOptions.projectName,
+		packageName: resolvedOptions.packageName
+	});
+	if (resolvedOptions.dryRun) {
+		await preflightWriteProject({
+			targetDir: resolvedOptions.targetDir,
+			tree,
+			overwrite: "never",
+			forbiddenTargetRoots: env.workspaceRoot ? [env.workspaceRoot] : []
+		});
+		const result = {
+			status: "dry-run",
+			targetDir: resolvedOptions.targetDir,
+			projectName: resolvedOptions.projectName,
+			packageName: resolvedOptions.packageName,
+			setupType: resolvedOptions.setupType,
+			installed: false,
+			installFailed: false,
+			gitInitialized: false,
+			gitCommitted: false,
+			gitSkippedReason: "dry-run",
+			gitFailed: false
+		};
+		logFinalOutput(result, env.output);
+		return result;
+	}
+	const gitProbeCwd = await fs.pathExists(resolvedOptions.targetDir) ? resolvedOptions.targetDir : env.cwd;
+	const gitSetup = await prepareInitialGitSetup({
+		explicitGitMode: resolvedOptions.git,
+		env,
+		runCommand,
+		probeDir: gitProbeCwd
+	});
+	const writeResult = await write({
+		targetDir: resolvedOptions.targetDir,
+		tree,
+		forbiddenTargetRoots: env.workspaceRoot ? [env.workspaceRoot] : []
+	});
+	let installed = false;
+	let installFailed = false;
+	if (resolvedOptions.install) {
+		env.output.log("Installing dependencies with pnpm...");
+		const installResult = await runCommand("pnpm", ["install"], writeResult.targetDir);
+		installed = installResult.ok;
+		installFailed = !installResult.ok;
+	}
+	const gitResult = await gitSetup.run(writeResult.targetDir);
+	const result = {
+		status: "created",
+		targetDir: writeResult.targetDir,
+		projectName: resolvedOptions.projectName,
+		packageName: resolvedOptions.packageName,
+		setupType: resolvedOptions.setupType,
+		installed,
+		installFailed,
+		gitInitialized: gitResult.gitInitialized,
+		gitCommitted: gitResult.gitCommitted,
+		gitSkippedReason: gitResult.gitSkippedReason,
+		gitFailed: gitResult.gitFailed
+	};
+	logFinalOutput(result, env.output);
+	return result;
+}
+//#endregion
+//#region src/commands/create.ts
+function normalizeCommanderOptions(options) {
+	return {
+		name: options.name,
+		packageName: options.packageName,
+		setup: options.setup,
+		setupType: options.setupType,
+		yes: options.yes,
+		install: options.install,
+		git: parseGitMode(options.git),
+		dryRun: options.dryRun
+	};
+}
+function createProgram(env) {
+	const program = new Command();
+	program.name("tenkit").description("Create a generated Tenkit Expo project.").version(CLI_VERSION).allowExcessArguments(false).option("--name <name>", `project folder name, defaults to ${DEFAULT_PROJECT_NAME} with --yes`).option("--package-name <name>", "generated package.json name override").option("-s, --setup <setup>", `public Setup slug: ${supportedSetupValues().join(", ")}`).option("--setup-type <setupType>", "canonical Setup Type ID or public Setup slug").option("--yes", "skip prompts and accept defaults").option("--no-install", "skip dependency installation").option("--git <mode>", "git behavior: init, commit, none").option("--no-git", "skip git initialization").option("--dry-run", "validate options and print the create plan without writing files").configureOutput({
+		writeOut: (message) => env.output.log(message.trimEnd()),
+		writeErr: (message) => env.output.error(message.trimEnd())
+	}).exitOverride().showHelpAfterError().action(async (options) => {
+		intro("Create Tenkit");
+		await runCreateFlow(normalizeCommanderOptions(options), env);
+		outro("Done");
+	});
+	return program;
+}
+//#endregion
+//#region src/prompts/create-prompts.ts
+function createPromptAdapter() {
+	return {
+		async text(options) {
+			const answer = await text({
+				...options,
+				validate(value) {
+					return options.validate(value);
+				}
+			});
+			return isCancel(answer) ? PROMPT_CANCELLED : String(answer);
+		},
+		async select(options) {
+			const answer = await select({
+				...options,
+				options: options.options.map((option) => ({
+					value: option.value,
+					label: option.label
+				}))
+			});
+			return isCancel(answer) ? PROMPT_CANCELLED : answer;
+		},
+		async confirm(options) {
+			const answer = await confirm(options);
+			return isCancel(answer) ? PROMPT_CANCELLED : answer;
+		}
+	};
+}
+//#endregion
+//#region src/cli.ts
+async function main(argv = process.argv.slice(2), io = process) {
+	const output = {
+		log(message = "") {
+			io.stdout.write(`${message}\n`);
+		},
+		error(message) {
+			io.stderr.write(`${message}\n`);
+		}
+	};
+	const workspaceRoot = await findTenkitWorkspaceRoot(import.meta.url);
+	const program = createProgram({
+		cwd: process.env.INIT_CWD ?? process.cwd(),
+		workspaceRoot,
+		isInteractive: io.stdin.isTTY === true && io.stdout.isTTY === true,
+		isCi: process.env.CI === "true",
+		output,
+		prompts: createPromptAdapter()
+	});
+	try {
+		await program.parseAsync(argv, { from: "user" });
+		return 0;
+	} catch (error) {
+		if (error instanceof CreateFlowCancelledError) {
+			cancel(error.message);
+			return 130;
+		}
+		if (error && typeof error === "object" && "code" in error && error.code === "commander.helpDisplayed") return 0;
+		if (error && typeof error === "object" && "code" in error && error.code === "commander.version") return 0;
+		const message = error instanceof Error ? error.message : String(error);
+		output.error(message);
+		return 1;
+	}
+}
+//#endregion
+//#region src/index.ts
+if (isDirectCliRun(import.meta.url, process.argv[1])) {
+	const exitCode = await main();
+	process.exitCode = exitCode;
+}
+//#endregion
+export { main };

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@tenkit/cli",
+  "version": "0.1.0",
+  "description": "Public Tenkit CLI implementation package.",
+  "license": "MIT",
+  "homepage": "https://github.com/brilliantinsane/tenkit#readme",
+  "bugs": {
+    "url": "https://github.com/brilliantinsane/tenkit/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/brilliantinsane/tenkit.git",
+    "directory": "packages/cli"
+  },
+  "keywords": [
+    "cli",
+    "expo",
+    "react-native",
+    "tenkit",
+    "typescript"
+  ],
+  "type": "module",
+  "bin": {
+    "tenkit": "./dist/index.mjs"
+  },
+  "exports": {
+    ".": "./dist/index.mjs"
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^1.6.0",
+    "commander": "^15.0.0",
+    "fs-extra": "^11.3.5",
+    "pathe": "^2.0.3",
+    "@tenkit/template-generator": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.9.3",
+    "tsdown": "^0.22.3",
+    "typescript": "~6.0.3",
+    "vitest": "^4.1.9"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "engines": {
+    "node": ">=22.14.0"
+  },
+  "scripts": {
+    "build": "pnpm -F @tenkit/template-generator build && tsdown src/index.ts --format esm --dts",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit --pretty false",
+    "pack:dry-run": "pnpm pack --dry-run"
+  }
+}