@tanstack/cli 0.0.1

package/dist/bin.mjs

@@ -0,0 +1,469 @@
+#!/usr/bin/env node
+import { A as writeConfigFile, a as initIntegration, d as fetchManifest, i as compileIntegration, j as compile, n as initTemplate, r as loadTemplate, t as compileTemplate, u as fetchIntegrations } from "./template-2SxOxCJc.mjs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { z } from "zod";
+import { Command } from "commander";
+import { cancel, confirm, intro, isCancel, log, multiselect, note, outro, select, spinner, text } from "@clack/prompts";
+import chalk from "chalk";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import express from "express";
+
+//#region src/commands/create.ts
+const PACKAGE_MANAGERS = [
+	"pnpm",
+	"npm",
+	"yarn",
+	"bun",
+	"deno"
+];
+function detectPackageManager() {
+	const userAgent = process.env.npm_config_user_agent;
+	if (userAgent) {
+		if (userAgent.includes("pnpm")) return "pnpm";
+		if (userAgent.includes("yarn")) return "yarn";
+		if (userAgent.includes("bun")) return "bun";
+		if (userAgent.includes("deno")) return "deno";
+	}
+	return "npm";
+}
+function validateProjectName(name) {
+	if (!name) return {
+		valid: false,
+		error: "Project name is required"
+	};
+	if (!/^[a-z0-9-_]+$/.test(name)) return {
+		valid: false,
+		error: "Project name can only contain lowercase letters, numbers, hyphens, and underscores"
+	};
+	return { valid: true };
+}
+function groupIntegrationsByCategory(integrations) {
+	const groups = {};
+	for (const integration of integrations) {
+		const category = integration.category ?? "other";
+		groups[category] ??= [];
+		groups[category].push(integration);
+	}
+	return groups;
+}
+const CATEGORY_LABELS = {
+	tanstack: "TanStack",
+	database: "Database",
+	orm: "ORM",
+	auth: "Authentication",
+	deploy: "Deployment",
+	tooling: "Tooling",
+	monitoring: "Monitoring",
+	api: "API",
+	i18n: "Internationalization",
+	cms: "CMS",
+	other: "Other"
+};
+const CATEGORY_ORDER = [
+	"tanstack",
+	"database",
+	"orm",
+	"auth",
+	"deploy",
+	"api",
+	"monitoring",
+	"tooling",
+	"i18n",
+	"cms",
+	"other"
+];
+async function runCreate(projectName, options) {
+	intro(chalk.bgCyan(chalk.black(" TanStack Start ")));
+	const s = spinner();
+	const integrationsPath = options.integrationsPath;
+	s.start("Fetching available integrations...");
+	let manifest;
+	try {
+		manifest = await fetchManifest(integrationsPath);
+		s.stop("Integrations loaded");
+	} catch (error$1) {
+		s.stop("Failed to fetch integrations");
+		log.error("Could not fetch integration manifest. Check your internet connection.");
+		process.exit(1);
+	}
+	let name = projectName;
+	if (!name && !options.yes) {
+		const nameInput = await text({
+			message: "Project name:",
+			placeholder: "my-tanstack-app",
+			defaultValue: "my-tanstack-app",
+			validate: (value) => {
+				const result = validateProjectName(value);
+				return result.valid ? void 0 : result.error;
+			}
+		});
+		if (isCancel(nameInput)) {
+			cancel("Operation cancelled.");
+			process.exit(0);
+		}
+		name = nameInput;
+	}
+	name = name ?? "my-tanstack-app";
+	const { valid, error } = validateProjectName(name);
+	if (!valid) {
+		log.error(error ?? "Invalid project name");
+		process.exit(1);
+	}
+	const targetDir = options.targetDir ? resolve(options.targetDir) : resolve(process.cwd(), name);
+	if (existsSync(targetDir)) {
+		if (!options.yes) {
+			const overwrite = await confirm({
+				message: `Directory ${chalk.cyan(name)} already exists. Overwrite?`,
+				initialValue: false
+			});
+			if (isCancel(overwrite) || !overwrite) {
+				cancel("Operation cancelled.");
+				process.exit(0);
+			}
+		}
+	}
+	let packageManager = options.packageManager ?? detectPackageManager();
+	if (!options.packageManager && !options.yes) {
+		const pmChoice = await select({
+			message: "Package manager:",
+			options: PACKAGE_MANAGERS.map((pm) => ({
+				value: pm,
+				label: pm
+			})),
+			initialValue: packageManager
+		});
+		if (isCancel(pmChoice)) {
+			cancel("Operation cancelled.");
+			process.exit(0);
+		}
+		packageManager = pmChoice;
+	}
+	let tailwind = options.tailwind ?? true;
+	if (options.tailwind === void 0 && !options.yes) {
+		const twChoice = await confirm({
+			message: "Include Tailwind CSS?",
+			initialValue: true
+		});
+		if (isCancel(twChoice)) {
+			cancel("Operation cancelled.");
+			process.exit(0);
+		}
+		tailwind = twChoice;
+	}
+	let selectedIntegrationIds = [];
+	if (options.integrations) selectedIntegrationIds = options.integrations.split(",").map((s$1) => s$1.trim());
+	else if (!options.yes) {
+		const grouped = groupIntegrationsByCategory(manifest.integrations.filter((a) => a.type === "integration" && a.modes.includes("file-router")));
+		const categoryOptions = CATEGORY_ORDER.filter((cat) => grouped[cat]?.length).map((cat) => ({
+			value: cat,
+			label: CATEGORY_LABELS[cat] ?? cat,
+			hint: `${grouped[cat].length} integrations`
+		}));
+		note("Use arrow keys to navigate, space to select/deselect, enter to confirm.", "Integration Selection");
+		const selectedCategories = await multiselect({
+			message: "Which categories would you like to explore?",
+			options: categoryOptions,
+			required: false
+		});
+		if (isCancel(selectedCategories)) {
+			cancel("Operation cancelled.");
+			process.exit(0);
+		}
+		for (const category of selectedCategories) {
+			const categoryIntegrations = grouped[category];
+			if (!categoryIntegrations?.length) continue;
+			const integrationChoices = await multiselect({
+				message: `Select ${CATEGORY_LABELS[category]} integrations:`,
+				options: categoryIntegrations.map((integration) => ({
+					value: integration.id,
+					label: integration.name,
+					hint: integration.description
+				})),
+				required: false
+			});
+			if (isCancel(integrationChoices)) {
+				cancel("Operation cancelled.");
+				process.exit(0);
+			}
+			selectedIntegrationIds.push(...integrationChoices);
+		}
+	}
+	const integrationMap = new Map(manifest.integrations.map((a) => [a.id, a]));
+	const resolvedIds = new Set(selectedIntegrationIds);
+	for (const id of selectedIntegrationIds) {
+		const integration = integrationMap.get(id);
+		if (integration?.dependsOn) for (const dep of integration.dependsOn) resolvedIds.add(dep);
+	}
+	if (resolvedIds.size > 0) note(Array.from(resolvedIds).map((id) => {
+		const integration = integrationMap.get(id);
+		return `  ${!selectedIntegrationIds.includes(id) && resolvedIds.has(id) ? chalk.dim("(auto)") : chalk.green("+")} ${integration?.name ?? id}`;
+	}).join("\n"), "Selected Integrations");
+	if (!options.yes) {
+		const proceed = await confirm({
+			message: "Create project?",
+			initialValue: true
+		});
+		if (isCancel(proceed) || !proceed) {
+			cancel("Operation cancelled.");
+			process.exit(0);
+		}
+	}
+	s.start("Preparing project...");
+	let customTemplate;
+	if (options.template) try {
+		customTemplate = await loadTemplate(options.template);
+		for (const integrationId of customTemplate.integrations) resolvedIds.add(integrationId);
+		tailwind = customTemplate.tailwind;
+	} catch (error$1) {
+		s.stop("Failed to load template");
+		log.error(error$1 instanceof Error ? error$1.message : "Could not load template from URL.");
+		process.exit(1);
+	}
+	let chosenIntegrations = [];
+	if (resolvedIds.size > 0) try {
+		chosenIntegrations = await fetchIntegrations(Array.from(resolvedIds), integrationsPath);
+	} catch (error$1) {
+		s.stop("Failed to fetch integration details");
+		log.error("Could not fetch integration definitions.");
+		process.exit(1);
+	}
+	const compileOptions = {
+		projectName: name,
+		framework: customTemplate?.framework ?? "react",
+		mode: customTemplate?.mode ?? "file-router",
+		typescript: customTemplate?.typescript ?? true,
+		tailwind,
+		packageManager,
+		chosenIntegrations,
+		integrationOptions: customTemplate?.integrationOptions ?? {},
+		customTemplate
+	};
+	const output = compile(compileOptions);
+	s.stop("Project prepared");
+	s.start("Writing files...");
+	mkdirSync(targetDir, { recursive: true });
+	for (const [filePath, content] of Object.entries(output.files)) {
+		const fullPath = resolve(targetDir, filePath);
+		mkdirSync(resolve(fullPath, ".."), { recursive: true });
+		writeFileSync(fullPath, content, "utf-8");
+	}
+	await writeConfigFile(targetDir, compileOptions);
+	s.stop("Files written");
+	if (options.git !== false) {
+		s.start("Initializing git repository...");
+		try {
+			const { execSync } = await import("node:child_process");
+			execSync("git init", {
+				cwd: targetDir,
+				stdio: "ignore"
+			});
+			s.stop("Git initialized");
+		} catch {
+			s.stop("Git initialization skipped");
+		}
+	}
+	if (options.install !== false) {
+		s.start(`Installing dependencies with ${packageManager}...`);
+		const startTime = Date.now();
+		const interval = setInterval(() => {
+			const elapsed = Math.floor((Date.now() - startTime) / 1e3);
+			s.message(`Installing dependencies with ${packageManager}... (${elapsed}s)`);
+		}, 1e3);
+		try {
+			const { execSync } = await import("node:child_process");
+			execSync(packageManager === "yarn" ? "yarn" : `${packageManager} install`, {
+				cwd: targetDir,
+				stdio: "ignore"
+			});
+			clearInterval(interval);
+			const total = Math.floor((Date.now() - startTime) / 1e3);
+			s.stop(`Dependencies installed (${total}s)`);
+		} catch {
+			clearInterval(interval);
+			s.stop("Dependency installation failed");
+			log.warning(`Run "${packageManager} install" manually to install dependencies.`);
+		}
+	}
+	const relativePath = resolve(process.cwd()) === targetDir ? "." : name;
+	outro(chalk.green("Project created successfully!"));
+	console.log();
+	console.log("Next steps:");
+	console.log();
+	if (relativePath !== ".") console.log(`  ${chalk.cyan("cd")} ${relativePath}`);
+	if (options.install === false) console.log(`  ${chalk.cyan(packageManager)} install`);
+	console.log(`  ${chalk.cyan(packageManager)} ${packageManager === "npm" ? "run " : ""}dev`);
+	console.log();
+	if (output.envVars.length > 0) {
+		console.log(chalk.yellow("Environment variables needed:"));
+		console.log();
+		for (const envVar of output.envVars) console.log(`  ${chalk.cyan(envVar.name)} - ${envVar.description}`);
+		console.log();
+		console.log(`  Add these to your ${chalk.cyan(".env.local")} file.`);
+		console.log();
+	}
+	for (const warning of output.warnings) log.warning(warning);
+}
+
+//#endregion
+//#region src/commands/mcp.ts
+function createServer() {
+	const server = new McpServer({
+		name: "TanStack CLI",
+		version: "0.0.1"
+	});
+	server.tool("listTanStackIntegrations", "List available integrations for creating TanStack applications", {}, async () => {
+		try {
+			const integrations = (await fetchManifest()).integrations.filter((a) => a.modes.includes("file-router")).map((integration) => ({
+				id: integration.id,
+				name: integration.name,
+				description: integration.description,
+				category: integration.category,
+				dependsOn: integration.dependsOn,
+				conflicts: integration.conflicts,
+				hasOptions: integration.hasOptions
+			}));
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(integrations, null, 2)
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: `Error fetching integrations: ${error}`
+			}] };
+		}
+	});
+	server.tool("createTanStackApplication", "Create a new TanStack Start application", {
+		projectName: z.string().describe("The name of the project (will be the directory name)"),
+		targetDir: z.string().describe("Absolute path where the project should be created"),
+		integrations: z.array(z.string()).optional().describe("Array of integration IDs to include. Use listTanStackIntegrations to see available options."),
+		integrationOptions: z.record(z.record(z.unknown())).optional().describe("Configuration for integrations. Format: {\"integrationId\": {\"optionName\": \"value\"}}"),
+		tailwind: z.boolean().optional().describe("Include Tailwind CSS (default: true)"),
+		packageManager: z.enum([
+			"npm",
+			"pnpm",
+			"yarn",
+			"bun",
+			"deno"
+		]).optional().describe("Package manager to use (default: pnpm)")
+	}, async ({ projectName, targetDir, integrations, integrationOptions, tailwind, packageManager }) => {
+		try {
+			const { mkdirSync: mkdirSync$1, writeFileSync: writeFileSync$1 } = await import("node:fs");
+			const { resolve: resolve$1 } = await import("node:path");
+			const { execSync } = await import("node:child_process");
+			let chosenIntegrations = [];
+			if (integrations?.length) chosenIntegrations = await fetchIntegrations(integrations);
+			const output = compile({
+				projectName,
+				framework: "react",
+				mode: "file-router",
+				typescript: true,
+				tailwind: tailwind ?? true,
+				packageManager: packageManager ?? "pnpm",
+				chosenIntegrations,
+				integrationOptions: integrationOptions ?? {}
+			});
+			mkdirSync$1(targetDir, { recursive: true });
+			for (const [filePath, content] of Object.entries(output.files)) {
+				const fullPath = resolve$1(targetDir, filePath);
+				mkdirSync$1(resolve$1(fullPath, ".."), { recursive: true });
+				writeFileSync$1(fullPath, content, "utf-8");
+			}
+			try {
+				execSync("git init", {
+					cwd: targetDir,
+					stdio: "ignore"
+				});
+			} catch {}
+			const envVarList = output.envVars.length > 0 ? `\n\nRequired environment variables:\n${output.envVars.map((e) => `- ${e.name}: ${e.description}`).join("\n")}` : "";
+			const warnings = output.warnings.length > 0 ? `\n\nWarnings:\n${output.warnings.map((w) => `- ${w}`).join("\n")}` : "";
+			return { content: [{
+				type: "text",
+				text: `Project "${projectName}" created successfully at ${targetDir}
+
+Files created: ${Object.keys(output.files).length}
+Integrations included: ${chosenIntegrations.map((a) => a.name).join(", ") || "none"}${envVarList}${warnings}
+
+Next steps:
+1. cd ${targetDir}
+2. ${packageManager ?? "pnpm"} install
+3. ${packageManager ?? "pnpm"} dev`
+			}] };
+		} catch (error) {
+			return { content: [{
+				type: "text",
+				text: `Error creating application: ${error}`
+			}] };
+		}
+	});
+	return server;
+}
+async function runMcp(options) {
+	const server = createServer();
+	if (options.sse) {
+		const app = express();
+		let transport = null;
+		app.get("/sse", (_req, res) => {
+			transport = new SSEServerTransport("/messages", res);
+			server.connect(transport);
+		});
+		app.post("/messages", (req, res) => {
+			if (transport) transport.handlePostMessage(req, res);
+		});
+		const port = parseInt(options.port ?? "8080", 10);
+		app.listen(port, () => {
+			console.log(`MCP server running at http://localhost:${port}/sse`);
+		});
+	} else {
+		const transport = new StdioServerTransport();
+		await server.connect(transport);
+	}
+}
+
+//#endregion
+//#region src/bin.ts
+const program = new Command();
+program.name("tanstack").description("TanStack CLI for scaffolding and tooling").version("0.0.1");
+program.command("create").argument("[project-name]", "name of the project").option("--template <template>", "URL to a custom template JSON file").option("--package-manager <pm>", "package manager (npm, pnpm, yarn, bun)").option("--integrations <integrations>", "comma-separated list of integration IDs").option("--no-install", "skip installing dependencies").option("--no-git", "skip initializing git repository").option("--no-tailwind", "skip tailwind CSS").option("-y, --yes", "skip prompts and use defaults").option("--target-dir <path>", "target directory for the project").option("--integrations-path <path>", "local path to integrations directory (for development)").description("Create a new TanStack Start project").action(runCreate);
+program.command("mcp").option("--sse", "run in SSE mode (for HTTP transport)").option("--port <port>", "port for SSE server", "8080").description("Start the MCP server for AI agents").action(runMcp);
+const integrationCommand = program.command("integration");
+integrationCommand.command("init").option("--integrations-path <path>", "local path to integrations directory (for development)").description("Initialize an integration from the current project").action(async (options) => {
+	try {
+		await initIntegration(resolve(process.cwd()), options.integrationsPath);
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "An error occurred");
+		process.exit(1);
+	}
+});
+integrationCommand.command("compile").option("--integrations-path <path>", "local path to integrations directory (for development)").description("Compile/update the integration from the current project").action(async (options) => {
+	try {
+		await compileIntegration(resolve(process.cwd()), options.integrationsPath);
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "An error occurred");
+		process.exit(1);
+	}
+});
+const templateCommand = program.command("template");
+templateCommand.command("init").description("Initialize a custom template from the current project").action(async () => {
+	try {
+		await initTemplate(resolve(process.cwd()));
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "An error occurred");
+		process.exit(1);
+	}
+});
+templateCommand.command("compile").description("Compile/update the custom template from the current project").action(async () => {
+	try {
+		await compileTemplate(resolve(process.cwd()));
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : "An error occurred");
+		process.exit(1);
+	}
+});
+program.parse();
+
+//#endregion
+export {  };

package/dist/index.cjs

@@ -0,0 +1,36 @@
+const require_template = require('./template-BYKvtZrT.cjs');
+
+exports.CONFIG_FILE = require_template.CONFIG_FILE;
+exports.CategorySchema = require_template.CategorySchema;
+exports.CommandSchema = require_template.CommandSchema;
+exports.CustomTemplateCompiledSchema = require_template.CustomTemplateCompiledSchema;
+exports.CustomTemplateInfoSchema = require_template.CustomTemplateInfoSchema;
+exports.EnvVarSchema = require_template.EnvVarSchema;
+exports.HookSchema = require_template.HookSchema;
+exports.IntegrationCompiledSchema = require_template.IntegrationCompiledSchema;
+exports.IntegrationInfoSchema = require_template.IntegrationInfoSchema;
+exports.IntegrationOptionSchema = require_template.IntegrationOptionSchema;
+exports.IntegrationOptionsSchema = require_template.IntegrationOptionsSchema;
+exports.IntegrationPhaseSchema = require_template.IntegrationPhaseSchema;
+exports.IntegrationTypeSchema = require_template.IntegrationTypeSchema;
+exports.ManifestIntegrationSchema = require_template.ManifestIntegrationSchema;
+exports.ManifestSchema = require_template.ManifestSchema;
+exports.RouteSchema = require_template.RouteSchema;
+exports.RouterModeSchema = require_template.RouterModeSchema;
+exports.compile = require_template.compile;
+exports.compileIntegration = require_template.compileIntegration;
+exports.compileTemplate = require_template.compileTemplate;
+exports.compileWithAttribution = require_template.compileWithAttribution;
+exports.fetchIntegration = require_template.fetchIntegration;
+exports.fetchIntegrationFiles = require_template.fetchIntegrationFiles;
+exports.fetchIntegrationInfo = require_template.fetchIntegrationInfo;
+exports.fetchIntegrations = require_template.fetchIntegrations;
+exports.fetchManifest = require_template.fetchManifest;
+exports.initIntegration = require_template.initIntegration;
+exports.initTemplate = require_template.initTemplate;
+exports.loadRemoteIntegration = require_template.loadRemoteIntegration;
+exports.loadTemplate = require_template.loadTemplate;
+exports.processTemplateFile = require_template.processTemplateFile;
+exports.readConfigFile = require_template.readConfigFile;
+exports.relativePath = require_template.relativePath;
+exports.writeConfigFile = require_template.writeConfigFile;