create-ripple 0.1.0-alpha.1

package/src/lib/prompts.js

@@ -0,0 +1,136 @@
+import prompts from 'prompts';
+import { validateProjectName } from './validation.js';
+import { getTemplateChoices } from './templates.js';
+import { red } from 'kleur/colors';
+
+/**
+ * Prompt for project name
+ * @param {string} defaultName - Default project name
+ * @returns {Promise<string>} - Project name
+ */
+export async function promptProjectName(defaultName = 'my-ripple-app') {
+	const response = await prompts({
+		type: 'text',
+		name: 'projectName',
+		message: 'What is your project named?',
+		initial: defaultName,
+		validate: (value) => {
+			const validation = validateProjectName(value);
+			return validation.valid || validation.message;
+		}
+	});
+
+	if (!response.projectName) {
+		console.log(red('✖ Operation cancelled'));
+		process.exit(1);
+	}
+
+	return response.projectName;
+}
+
+/**
+ * Prompt for template selection
+ * @returns {Promise<string>} - Selected template name
+ */
+export async function promptTemplate() {
+	const response = await prompts({
+		type: 'select',
+		name: 'template',
+		message: 'Which template would you like to use?',
+		choices: getTemplateChoices(),
+		initial: 0
+	});
+
+	if (!response.template) {
+		console.log(red('✖ Operation cancelled'));
+		process.exit(1);
+	}
+
+	return response.template;
+}
+
+/**
+ * Prompt for directory overwrite confirmation
+ * @param {string} projectName - The project name
+ * @returns {Promise<boolean>} - Whether to overwrite
+ */
+export async function promptOverwrite(projectName) {
+	const response = await prompts({
+		type: 'confirm',
+		name: 'overwrite',
+		message: `Directory "${projectName}" already exists. Continue anyway?`,
+		initial: false
+	});
+
+	if (response.overwrite === undefined) {
+		console.log(red('✖ Operation cancelled'));
+		process.exit(1);
+	}
+
+	return response.overwrite;
+}
+
+/**
+ * Prompt for package manager selection
+ * @returns {Promise<string>} - Selected package manager
+ */
+export async function promptPackageManager() {
+	const response = await prompts({
+		type: 'select',
+		name: 'packageManager',
+		message: 'Which package manager would you like to use?',
+		choices: [
+			{ title: 'npm', value: 'npm', description: 'Use npm for dependency management' },
+			{ title: 'yarn', value: 'yarn', description: 'Use Yarn for dependency management' },
+			{ title: 'pnpm', value: 'pnpm', description: 'Use pnpm for dependency management' }
+		],
+		initial: 0
+	});
+
+	if (!response.packageManager) {
+		console.log(red('✖ Operation cancelled'));
+		process.exit(1);
+	}
+
+	return response.packageManager;
+}
+
+/**
+ * Prompt for TypeScript usage
+ * @returns {Promise<boolean>} - Whether to use TypeScript
+ */
+export async function promptTypeScript() {
+	const response = await prompts({
+		type: 'confirm',
+		name: 'typescript',
+		message: 'Would you like to use TypeScript?',
+		initial: true
+	});
+
+	if (response.typescript === undefined) {
+		console.log(red('✖ Operation cancelled'));
+		process.exit(1);
+	}
+
+	return response.typescript;
+}
+
+/**
+ * Prompt for Git initialization
+ * @returns {Promise<boolean>} - Whether to initialize Git
+ */
+export async function promptGitInit() {
+	const response = await prompts({
+		type: 'confirm',
+		name: 'gitInit',
+		message: 'Initialize a new Git repository?',
+		initial: true
+	});
+
+	if (response.gitInit === undefined) {
+		console.log(red('✖ Operation cancelled'));
+		process.exit(1);
+	}
+
+	return response.gitInit;
+}

package/src/lib/templates.js

@@ -0,0 +1,97 @@
+import { join } from 'node:path';
+import { existsSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import degit from 'degit';
+import { GITHUB_REPO, GITHUB_TEMPLATES_DIRECTORY, TEMPLATES } from '../constants.js';
+
+/**
+ * Get template by name
+ * @param {string} templateName - The template name
+ * @returns {object|null} - Template object or null if not found
+ */
+export function getTemplate(templateName) {
+	return TEMPLATES.find((template) => template.name === templateName) || null;
+}
+
+/**
+ * Get all available template names
+ * @returns {string[]} - Array of template names
+ */
+export function getTemplateNames() {
+	return TEMPLATES.map((template) => template.name);
+}
+
+/**
+ * Get template choices for prompts
+ * @returns {object[]} - Array of choice objects for prompts
+ */
+export function getTemplateChoices() {
+	return TEMPLATES.map((template) => ({
+		title: template.display,
+		description: template.description,
+		value: template.name
+	}));
+}
+
+/**
+ * Validate if template exists in our template list
+ * @param {string} templateName - The template name to validate
+ * @returns {boolean} - True if template exists in TEMPLATES list
+ */
+export function validateTemplate(templateName) {
+	if (!templateName) return false;
+	const template = getTemplate(templateName);
+	return template !== null;
+}
+
+/**
+ * Download template from GitHub repository
+ * @param {string} templateName - The template name to download
+ * @returns {Promise<string>} - Path to downloaded template directory
+ */
+export async function downloadTemplate(templateName) {
+	if (!validateTemplate(templateName)) {
+		throw new Error(`Template "${templateName}" not found`);
+	}
+
+	// Create a temporary directory for the template
+	const tempDir = join(tmpdir(), `ripple-template-${templateName}-${Date.now()}`);
+	mkdirSync(tempDir, { recursive: true });
+
+	// Use degit to download the specific template from GitHub
+	const repoUrl = `${GITHUB_REPO}/${GITHUB_TEMPLATES_DIRECTORY}/${templateName}`;
+	const emitter = degit(repoUrl, {
+		cache: false,
+		force: true,
+		verbose: false
+	});
+
+	try {
+		await emitter.clone(tempDir);
+		return tempDir;
+	} catch (error) {
+		throw new Error(`Failed to download template "${templateName}": ${error.message}`);
+	}
+}
+
+/**
+ * Get template directory path (for local development)
+ * @param {string} templateName - The template name
+ * @returns {string} - Absolute path to template directory
+ */
+export function getLocalTemplatePath(templateName) {
+	// This is used for local development in the monorepo
+	const repoRoot = join(process.cwd(), '../../../');
+	return join(repoRoot, 'templates', templateName);
+}
+
+/**
+ * Check if we're running in development mode (monorepo)
+ * @returns {boolean} - True if in development mode
+ */
+export function isLocalDevelopment() {
+	// Check if we're in the monorepo by looking for the templates directory
+	const repoRoot = join(process.cwd(), '../../../');
+	const templatesDir = join(repoRoot, 'templates');
+	return existsSync(templatesDir);
+}

package/src/lib/validation.js

@@ -0,0 +1,155 @@
+/**
+ * Validation utilities for project creation
+ */
+
+/**
+ * Validates a project name according to npm package naming rules
+ * @param {string} name - The project name to validate
+ * @returns {object} - Object with valid boolean and message string
+ */
+export function validateProjectName(name) {
+	if (typeof name !== 'string' || name === null || name === undefined) {
+		return {
+			valid: false,
+			message: 'Project name is required'
+		};
+	}
+
+	name = name.trim();
+
+	if (name.length === 0) {
+		return {
+			valid: false,
+			message: 'Project name cannot be empty'
+		};
+	}
+
+	// Check length (npm package names have a 214 character limit)
+	if (name.length > 214) {
+		return {
+			valid: false,
+			message: 'Project name must be less than 214 characters'
+		};
+	}
+
+	// Check for valid characters (npm allows lowercase letters, numbers, hyphens, and dots)
+	if (!/^[a-z0-9._-]+$/.test(name)) {
+		return {
+			valid: false,
+			message:
+				'Project name can only contain lowercase letters, numbers, hyphens, dots, and underscores'
+		};
+	}
+
+	// Cannot start with dot or underscore
+	if (name.startsWith('.') || name.startsWith('_')) {
+		return {
+			valid: false,
+			message: 'Project name cannot start with a dot or underscore'
+		};
+	}
+
+	// Cannot end with dot
+	if (name.endsWith('.')) {
+		return {
+			valid: false,
+			message: 'Project name cannot end with a dot'
+		};
+	}
+
+	// Cannot contain consecutive dots
+	if (name.includes('..')) {
+		return {
+			valid: false,
+			message: 'Project name cannot contain consecutive dots'
+		};
+	}
+
+	// Reserved names
+	const reservedNames = [
+		'node_modules',
+		'favicon.ico',
+		'con',
+		'prn',
+		'aux',
+		'nul',
+		'com1',
+		'com2',
+		'com3',
+		'com4',
+		'com5',
+		'com6',
+		'com7',
+		'com8',
+		'com9',
+		'lpt1',
+		'lpt2',
+		'lpt3',
+		'lpt4',
+		'lpt5',
+		'lpt6',
+		'lpt7',
+		'lpt8',
+		'lpt9'
+	];
+
+	if (reservedNames.includes(name.toLowerCase())) {
+		return {
+			valid: false,
+			message: `"${name}" is a reserved name and cannot be used`
+		};
+	}
+
+	return {
+		valid: true,
+		message: ''
+	};
+}
+
+/**
+ * Converts a project name to a valid directory name
+ * @param {string} name - The project name
+ * @returns {string} - A valid directory name
+ */
+export function sanitizeDirectoryName(name) {
+	return name
+		.toLowerCase()
+		.replace(/[^a-z0-9-]/g, '-')
+		.replace(/^-+|-+$/g, '')
+		.replace(/-+/g, '-');
+}
+
+/**
+ * Validates directory path and checks if it's writable
+ * @param {string} path - The directory path to validate
+ * @returns {object} - Object with valid boolean and message string
+ */
+export function validateDirectoryPath(path) {
+	if (!path || typeof path !== 'string') {
+		return {
+			valid: false,
+			message: 'Directory path is required'
+		};
+	}
+
+	// Check if path is absolute or relative
+	if (path.startsWith('/') && path.length < 2) {
+		return {
+			valid: false,
+			message: 'Cannot create project in root directory'
+		};
+	}
+
+	// Check for invalid characters in path
+	if (/[<>:"|?*]/.test(path)) {
+		return {
+			valid: false,
+			message: 'Directory path contains invalid characters'
+		};
+	}
+
+	return {
+		valid: true,
+		message: ''
+	};
+}

package/tests/integration/cli.test.js

@@ -0,0 +1,179 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const CLI_PATH = join(__dirname, '../../src/index.js');
+
+describe('CLI Integration Tests', () => {
+	let testDir;
+
+	beforeEach(() => {
+		testDir = join(tmpdir(), `cli-test-${Date.now()}`);
+		mkdirSync(testDir, { recursive: true });
+	});
+
+	afterEach(() => {
+		if (existsSync(testDir)) {
+			rmSync(testDir, { recursive: true, force: true });
+		}
+	});
+
+	// Helper function to run CLI commands
+	const runCLI = (args = [], input = '', timeout = 10000) => {
+		return new Promise((resolve, reject) => {
+			const child = spawn('node', [CLI_PATH, ...args], {
+				cwd: testDir,
+				stdio: 'pipe'
+			});
+
+			let stdout = '';
+			let stderr = '';
+
+			child.stdout.on('data', (data) => {
+				stdout += data.toString();
+			});
+
+			child.stderr.on('data', (data) => {
+				stderr += data.toString();
+			});
+
+			child.on('close', (code) => {
+				resolve({ code, stdout, stderr });
+			});
+
+			child.on('error', reject);
+
+			if (input) {
+				child.stdin.write(input);
+			}
+			child.stdin.end();
+
+			setTimeout(() => {
+				child.kill();
+				reject(new Error('Command timed out'));
+			}, timeout);
+		});
+	};
+
+	it('should show help when --help flag is used', async () => {
+		const result = await runCLI(['--help']);
+
+		expect(result.code).toBe(0);
+		expect(result.stdout).toContain('Interactive CLI tool for creating Ripple applications');
+		expect(result.stdout).toContain('Usage: create-ripple-app');
+		expect(result.stdout).toContain('Arguments:');
+		expect(result.stdout).toContain('Options:');
+		expect(result.stdout).toContain('--template');
+		expect(result.stdout).toContain('--package-manager');
+	});
+
+	it('should show version when --version flag is used', async () => {
+		const result = await runCLI(['--version']);
+
+		expect(result.code).toBe(0);
+		expect(result.stdout.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+	});
+
+	it('should create project with all arguments provided', async () => {
+		const projectName = 'test-cli-project';
+		const result = await runCLI([
+			projectName,
+			'--template', 'basic',
+			'--package-manager', 'npm',
+			'--no-git',
+			'--yes'
+		]);
+
+		expect(result.code).toBe(0);
+		expect(result.stdout).toContain('Welcome to Create Ripple App');
+		expect(result.stdout).toContain('Creating Ripple app');
+		expect(result.stdout).toContain('Project created successfully');
+		expect(result.stdout).toContain('Next steps:');
+		expect(result.stdout).toContain(`cd ${projectName}`);
+		expect(result.stdout).toContain('npm install');
+		expect(result.stdout).toContain('npm run dev');
+
+		expect(existsSync(join(testDir, projectName))).toBe(true);
+		expect(existsSync(join(testDir, projectName, 'package.json'))).toBe(true);
+	});
+
+	it('should handle invalid template gracefully', async () => {
+		const result = await runCLI([
+			'test-project',
+			'--template', 'invalid-template',
+			'--yes'
+		]);
+
+		expect(result.code).toBe(1);
+		expect(result.stderr).toContain('Template "invalid-template" not found');
+		expect(result.stderr).toContain('Available templates:');
+	});
+
+	it('should handle invalid project name gracefully', async () => {
+		const result = await runCLI([
+			'Invalid Project Name!',
+			'--yes'
+		]);
+
+		expect(result.code).toBe(1);
+		expect(result.stderr).toContain('Project name can only contain lowercase letters');
+	});
+
+	it('should show different package manager commands based on selection', async () => {
+		const projectName = 'test-pnpm-project';
+		const result = await runCLI([
+			projectName,
+			'--template', 'basic',
+			'--package-manager', 'pnpm',
+			'--yes'
+		]);
+
+		expect(result.code).toBe(0);
+		expect(result.stdout).toContain('pnpm install');
+		expect(result.stdout).toContain('pnpm dev');
+	});
+
+	it('should handle yarn package manager', async () => {
+		const projectName = 'test-yarn-project';
+		const result = await runCLI([
+			projectName,
+			'--template', 'basic',
+			'--package-manager', 'yarn',
+			'--yes'
+		]);
+
+		expect(result.code).toBe(0);
+		expect(result.stdout).toContain('yarn install');
+		expect(result.stdout).toContain('yarn dev');
+	});
+
+	it('should handle project directory that already exists (with --yes)', async () => {
+		const projectName = 'existing-project';
+		const projectPath = join(testDir, projectName);
+
+		mkdirSync(projectPath, { recursive: true });
+		writeFileSync(join(projectPath, 'existing-file.txt'), 'test');
+
+		const result = await runCLI([
+			projectName,
+			'--template', 'basic',
+			'--yes'
+		]);
+
+		expect(result.code).toBe(0);
+		expect(result.stdout).toContain('Project created successfully');
+	});
+
+	it('should validate all required dependencies are available', async () => {
+		const result = await runCLI(['--help']);
+		expect(result.code).toBe(0);
+		expect(result.stderr).toBe('');
+	});
+});