tackl 1.0.10 → 2.2.0

package/README.md

@@ -1,75 +1,33 @@
 # Tackl CLI
 
-The ultimate Next.js starter kit with Waffl Grid system.
-
-## Installation
-
-```bash
-npm install -g tackl
-```
+Scaffolds [Tackl](https://github.com/12-studio/tackl) — the animation-first Next.js starter kit — **into the current directory**. Made for the "empty git repo" workflow: create your repo, clone it, run one command.
 
 ## Usage
 
 ```bash
-tackl my-app
+mkdir my-app && cd my-app   # or clone your empty repo and cd in
+bunx tackl                  # or: bun create tackl / npm create tackl@latest
 ```
 
-### Options
-
-- `--ref <branch>` - Template ref (branch or tag) (default: main)
-- `--no-install` - Skip dependency installation
-- `--no-git` - Skip git initialization
-- `--help` - Show help message
+You'll be asked which CMS to use — **DatoCMS**, **Sanity**, or **None** — and the scaffold is pruned to match: only the chosen adapter, its dependencies, its docs, and its `.env.example` block survive.
 
-### Examples
+Choosing **Sanity** sets the whole thing up: an embedded Studio at `/studio`, example schemas, and draft-mode preview routes ship in the scaffold, and the CLI offers to run `sanity init` for you — logging in, creating/linking a project, and writing your `.env`. Scaffold → `bun run dev` → `/studio` → start editing.
 
-```bash
-# Create a new project
-tackl my-app
-
-# Create with specific branch
-tackl my-app --ref develop
-
-# Skip installation and git
-tackl my-app --no-install --no-git
-```
+On your first `bun run dev`, a **setup wizard** greets you in the browser: it walks through every theme token (colours, spacing, motion, fonts, the type scale), writes your answers into `src/theme`, then deletes itself — skip it to keep the starter defaults. The scaffold commit the CLI makes is your restore point if you ever want to run it again.
 
-## What's Included
+## What it does
 
-- ⚡ **Next.js 15** with App Router
-- 🎨 **Waffl Grid System** - Responsive grid with smart breakpoint inheritance
-- 🎭 **Styled Components** - CSS-in-JS with TypeScript
-- 🎬 **GSAP** - Professional animations
-- 📱 **Responsive Design** - Mobile-first approach
-- 🔧 **TypeScript** - Full type safety
-- 🎯 **Performance** - Optimized for speed
-- 📦 **Modern Tooling** - ESLint, Prettier, Husky
+1. Verifies the directory is empty (an existing `.git`, `.gitignore`, `README.md` or `LICENSE` is fine — your repo's `.git` and remote are kept)
+2. Downloads the latest tagged release of the template (falls back to `main` if none)
+3. Prunes repo-only cargo (the CLI itself, `.github`) and the unused CMS adapter
+4. Sets your package name, initialises git if needed, and runs `bun install`
 
-## Features
+## Options
 
-### Waffl Grid System
-
-- Smart breakpoint inheritance (only specify what changes!)
-- Responsive grid columns
-- Semantic components
-- CSS custom properties
-
-### Example Usage
-
-```jsx
-<Waffl>
-	<Section $s='1/-1' $l='3/9'>
-		// Mobile: full width, Desktop: 3/9 // Tablet inherits mobile (full
-		width) Content
-	</Section>
-</Waffl>
 ```
-
-## Repository
-
-- **GitHub**: https://github.com/12-studio/tackl
-- **Issues**: https://github.com/12-studio/tackl/issues
-
-## License
-
-MIT
+--cms <dato|sanity|none>   Skip the CMS prompt
+--name <name>              Package name (default: directory name)
+--ref <tag|branch>         Template ref (default: latest release)
+--no-install               Skip dependency installation
+--no-git                   Skip git init (an existing .git is always kept)
+```

package/bin/tackl.js

@@ -1,19 +1,15 @@
 #!/usr/bin/env node
-import { execSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import pc from 'picocolors';
 import prompts from 'prompts';
 import * as tar from 'tar';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
 
 const OWNER = '12-studio';
 const REPO = 'tackl';
-const DEFAULT_REF = 'main';
+const FALLBACK_REF = 'main';
 
 const log = {
 	info: m => console.log(pc.cyan('•'), m),
@@ -21,11 +17,10 @@ const log = {
 	warn: m => console.log(pc.yellow('▲'), m),
 	error: m => console.log(pc.red('✖'), m),
 	step: m => console.log(pc.blue('→'), m),
-	success: m => console.log(pc.green('🎉'), m),
 };
 
 const showBanner = () => {
-	const purple = str => `\x1b[38;5;99m${str}\x1b[0m`; // Deep vibrant purple
+	const purple = str => `\x1b[38;5;99m${str}\x1b[0m`;
 	console.log(
 		pc.bold(
 			purple(`
@@ -40,221 +35,303 @@ const showBanner = () => {
 ║                                                 ║
 ║         The Ultimate Next.js Starter Kit        ║
 ║                                                 ║
-╚═════════════════════════════════════════════════╝                                                                   
+╚═════════════════════════════════════════════════╝
 	`)
 		)
 	);
 };
 
+// SECTION • Directory checks
+// NOTE • The CLI scaffolds INTO the current directory — run it inside an
+// empty (or freshly-initialised) git repo. These files are allowed to
+// already exist without counting as "not empty".
+const ALLOWED_EXISTING = new Set(['.git', '.gitignore', 'README.md', 'LICENSE', '.DS_Store']);
+
+const dirIsScaffoldable = dir => {
+	if (!fs.existsSync(dir)) return true;
+	return fs.readdirSync(dir).every(entry => ALLOWED_EXISTING.has(entry));
+};
+
+// SECTION • Template ref resolution
+// NOTE • Prefer the latest GitHub release so every scaffold is a tested,
+// reproducible snapshot; fall back to main (with a warning) when no
+// release exists. --ref overrides both.
+const resolveRef = async explicitRef => {
+	if (explicitRef) return { ref: explicitRef, source: 'flag' };
+	try {
+		const res = await fetch(`https://api.github.com/repos/${OWNER}/${REPO}/releases/latest`, {
+			headers: { accept: 'application/vnd.github+json' },
+		});
+		if (res.ok) {
+			const json = await res.json();
+			if (json?.tag_name) return { ref: json.tag_name, source: 'release' };
+		}
+	} catch {}
+	return { ref: FALLBACK_REF, source: 'fallback' };
+};
+
+// SECTION • Pruning
+const rmrf = (root, rel) => {
+	const p = path.join(root, rel);
+	if (fs.existsSync(p)) fs.rmSync(p, { recursive: true, force: true });
+};
+
+const stripEnvBlock = (root, marker) => {
+	const p = path.join(root, '.env.example');
+	if (!fs.existsSync(p)) return;
+	const lines = fs.readFileSync(p, 'utf8').split('\n');
+	const out = [];
+	let skipping = false;
+	for (const line of lines) {
+		if (line.startsWith(marker)) {
+			skipping = true;
+			continue;
+		}
+		if (skipping && line.trim() === '') {
+			skipping = false;
+			continue;
+		}
+		if (!skipping) out.push(line);
+	}
+	fs.writeFileSync(p, out.join('\n'));
+};
+
+const stripDeps = (root, deps) => {
+	const p = path.join(root, 'package.json');
+	if (!fs.existsSync(p)) return;
+	const json = JSON.parse(fs.readFileSync(p, 'utf8'));
+	for (const d of deps) {
+		delete json.dependencies?.[d];
+		delete json.devDependencies?.[d];
+	}
+	fs.writeFileSync(p, `${JSON.stringify(json, null, '\t')}\n`);
+};
+
+// NOTE • Everything that exists solely for the embedded Sanity Studio
+const SANITY_STUDIO_PATHS = ['app/(studio)', 'app/api/draft-mode', 'sanity.config.ts', 'sanity'];
+const SANITY_DEPS = ['next-sanity', 'sanity', '@sanity/vision'];
+
+const CMS = {
+	dato: {
+		title: 'DatoCMS',
+		prune: root => {
+			rmrf(root, 'src/cms/sanity');
+			rmrf(root, 'docs/Sanity');
+			for (const p of SANITY_STUDIO_PATHS) rmrf(root, p);
+			stripDeps(root, SANITY_DEPS);
+			stripEnvBlock(root, '# CMS — Sanity');
+		},
+	},
+	sanity: {
+		title: 'Sanity',
+		prune: root => {
+			rmrf(root, 'src/cms/dato');
+			rmrf(root, 'docs/DatoCMS');
+			stripDeps(root, ['@datocms/cda-client', 'react-datocms', 'graphql', 'graphql-tag']);
+			stripEnvBlock(root, '# CMS — DatoCMS');
+			// Rewire the adapter entry to the kept adapter
+			const entry = path.join(root, 'src/cms/index.ts');
+			if (fs.existsSync(entry)) {
+				fs.writeFileSync(entry, fs.readFileSync(entry, 'utf8').replace(`'./dato'`, `'./sanity'`));
+			}
+		},
+	},
+	none: {
+		title: 'No CMS',
+		prune: root => {
+			rmrf(root, 'src/cms');
+			rmrf(root, 'docs/Sanity');
+			rmrf(root, 'docs/DatoCMS');
+			rmrf(root, 'docs/CMS.md');
+			for (const p of SANITY_STUDIO_PATHS) rmrf(root, p);
+			stripDeps(root, [...SANITY_DEPS, '@datocms/cda-client', 'react-datocms', 'graphql', 'graphql-tag']);
+			stripEnvBlock(root, '# CMS — Sanity');
+			stripEnvBlock(root, '# CMS — DatoCMS');
+		},
+	},
+};
+
+// NOTE • Repo-only cargo that should never land in a scaffolded project
+const REPO_CARGO = ['tackl', '.github', 'bun.lock'];
+
 async function main() {
 	const args = process.argv.slice(2);
 
-	// Handle help flag
 	if (args.includes('--help') || args.includes('-h')) {
 		console.log(`
 ${pc.bold('Tackl CLI')} - The ultimate Next.js starter kit
 
 ${pc.bold('Usage:')}
-  tackl [project-name] [options]
+  Run inside an empty directory (or a freshly-initialised git repo):
 
-${pc.bold('Options:')}
-  --no-install       Skip dependency installation (default: install)
-  --no-git           Skip git initialization (default: init)
-  -h, --help         Show this help message
-
-${pc.bold('Examples:')}
-  tackl my-app                    # Creates project with npm install + git init
-  tackl my-app --no-install       # Creates project with git init only
-  tackl my-app --no-git           # Creates project with npm install only
-  tackl my-app --no-install --no-git  # Creates project only
+  mkdir my-app && cd my-app
+  bunx tackl
 
-${pc.bold('Repository:')} https://github.com/12-studio/tackl
+${pc.bold('Options:')}
+  --cms <dato|sanity|none>   Skip the CMS prompt
+  --name <name>              Package name (default: the directory name)
+  --ref <tag|branch>         Template ref (default: latest release)
+  --no-install               Skip dependency installation
+  --no-git                   Skip git init (existing .git is always kept)
+  -h, --help                 Show this help message
+
+${pc.bold('Repository:')} https://github.com/${OWNER}/${REPO}
 		`);
 		process.exit(0);
 	}
 
-	const argName = args.find(a => !a.startsWith('-'));
-
-	const initial = {
-		name: argName,
-		ref: DEFAULT_REF, // Always use main branch
-		install: !args.includes('--no-install'), // Default: true (install)
-		git: !args.includes('--no-git'), // Default: true (init git)
+	const flagValue = name => {
+		const i = args.indexOf(name);
+		return i !== -1 ? args[i + 1] : undefined;
 	};
 
-	// Filter out null prompts
-	const promptQuestions = [
-		{
-			type: initial.name ? null : 'text',
-			name: 'name',
-			message: 'Project directory',
-			initial: 'my-tackl-app',
-			validate: v =>
-				/^[a-z0-9\-._]+$/.test(v)
-					? true
-					: 'Use lowercase letters, numbers, - . _',
-		},
-	].filter(q => q.type !== null);
+	const targetDir = process.cwd();
 
-	const answers = await prompts(promptQuestions, {
-		onCancel: () => {
-			log.warn('Cancelled.');
-			process.exit(1);
-		},
-		onSubmit: () => {
-			// Clean up terminal
-			process.stdout.write('\x1b[?25h');
-		},
-	});
-
-	const projectName = (answers.name || initial.name).trim();
-	const ref = initial.ref; // Always use main branch
-	const doInstall = initial.install; // Default: true
-	const doGit = initial.git; // Default: true
-
-	// Validate project name
-	if (!projectName) {
-		log.error('Project name is required.');
-		process.exit(1);
-	}
-
-	const targetDir = path.resolve(process.cwd(), projectName);
-	if (fs.existsSync(targetDir) && fs.readdirSync(targetDir).length > 0) {
+	if (!dirIsScaffoldable(targetDir)) {
 		log.error(
-			`Directory "${projectName}" already exists and is not empty.`
+			'This directory is not empty. Run tackl inside an empty directory (a .git folder, .gitignore, README.md and LICENSE are fine).'
 		);
 		process.exit(1);
 	}
-	fs.mkdirSync(targetDir, { recursive: true });
 
 	showBanner();
-	console.log(pc.bold(pc.white('🚀 Starting project creation...\n')));
 
-	log.step(`Creating project: ${pc.bold(pc.cyan(projectName))}`);
-	log.step(`Template: ${pc.bold(pc.yellow(`${OWNER}/${REPO}@${ref}`))}`);
-	console.log();
+	// SECTION • Gather choices
+	const cmsFlag = flagValue('--cms');
+	if (cmsFlag && !CMS[cmsFlag]) {
+		log.error(`Unknown --cms value "${cmsFlag}". Use dato, sanity or none.`);
+		process.exit(1);
+	}
 
-	const tarUrl = `https://codeload.github.com/${OWNER}/${REPO}/tar.gz/${encodeURIComponent(ref)}`;
-	const tmpTar = path.join(os.tmpdir(), `tackl-${Date.now()}.tgz`);
+	const answers = await prompts(
+		[
+			{
+				type: cmsFlag ? null : 'select',
+				name: 'cms',
+				message: 'Which CMS should this project use?',
+				choices: [
+					{ title: 'DatoCMS', value: 'dato' },
+					{ title: 'Sanity', value: 'sanity' },
+					{ title: 'None', value: 'none' },
+				],
+				initial: 0,
+			},
+		].filter(q => q.type !== null),
+		{
+			onCancel: () => {
+				log.warn('Cancelled.');
+				process.exit(1);
+			},
+		}
+	);
 
-	try {
-		log.step('📥 Downloading template...');
-		const res = await fetch(tarUrl);
-		if (!res.ok)
-			throw new Error(`Download failed: ${res.status} ${res.statusText}`);
+	const cms = cmsFlag || answers.cms;
+	const rawName = flagValue('--name') || path.basename(targetDir);
+	const projectName =
+		rawName
+			.toLowerCase()
+			.replace(/[^a-z0-9\-._]/g, '-')
+			.replace(/^[-.]+|[-.]+$/g, '') || 'tackl-app';
+	const doInstall = !args.includes('--no-install');
+	const doGit = !args.includes('--no-git');
+	const hadGit = fs.existsSync(path.join(targetDir, '.git'));
 
-		// Convert response to buffer and write to file
-		const arrayBuffer = await res.arrayBuffer();
-		const buffer = Buffer.from(arrayBuffer);
-		fs.writeFileSync(tmpTar, buffer);
+	const { ref, source } = await resolveRef(flagValue('--ref'));
+	if (source === 'fallback') log.warn(`No release found — using ${FALLBACK_REF} (untagged).`);
 
-		log.ok('Template downloaded successfully!');
-	} catch (e) {
-		log.error(`Download failed: ${e.message}`);
-		log.error('Please check your internet connection and try again.');
-		process.exit(1);
+	console.log();
+	log.step(`Scaffolding ${pc.bold(pc.cyan(projectName))} in ${pc.bold(targetDir)}`);
+	log.step(`Template: ${pc.bold(pc.yellow(`${OWNER}/${REPO}@${ref}`))} · CMS: ${pc.bold(CMS[cms].title)}`);
+	console.log();
+
+	// NOTE • If the repo already has its own LICENSE, that choice wins —
+	// stash it and restore it after extraction (the template ships MIT)
+	const licensePath = path.join(targetDir, 'LICENSE');
+	const existingLicense = fs.existsSync(licensePath) ? fs.readFileSync(licensePath, 'utf8') : null;
+
+	// SECTION • Download + extract
+	// NOTE • TACKL_TEMPLATE_TAR points at a local tarball — used by tests/CI
+	const tmpTar = process.env.TACKL_TEMPLATE_TAR || path.join(os.tmpdir(), `tackl-${Date.now()}.tgz`);
+
+	if (!process.env.TACKL_TEMPLATE_TAR) {
+		const tarUrl = `https://codeload.github.com/${OWNER}/${REPO}/tar.gz/${encodeURIComponent(ref)}`;
+		try {
+			log.step('📥 Downloading template...');
+			const res = await fetch(tarUrl);
+			if (!res.ok) throw new Error(`Download failed: ${res.status} ${res.statusText}`);
+			fs.writeFileSync(tmpTar, Buffer.from(await res.arrayBuffer()));
+			log.ok('Template downloaded!');
+		} catch (e) {
+			log.error(`Download failed: ${e.message}`);
+			log.error('Please check your internet connection and try again.');
+			process.exit(1);
+		}
 	}
 
 	try {
 		log.step('📦 Extracting files...');
 		await tar.x({ file: tmpTar, cwd: targetDir, strip: 1 });
-		log.ok('Files extracted successfully!');
+		log.ok('Files extracted!');
 	} catch (e) {
 		log.error(`Extraction failed: ${e.message}`);
-		log.error('Please try again or check if the template is valid.');
 		process.exit(1);
 	} finally {
-		try {
-			fs.unlinkSync(tmpTar);
-		} catch {}
+		if (!process.env.TACKL_TEMPLATE_TAR) {
+			try {
+				fs.unlinkSync(tmpTar);
+			} catch {}
+		}
 	}
 
-	// Remove template .git if present
-	try {
-		const gitPath = path.join(targetDir, '.git');
-		if (fs.existsSync(gitPath))
-			fs.rmSync(gitPath, { recursive: true, force: true });
-	} catch {}
-
-	// Remove any existing lock files to ensure npm is used
-	try {
-		const yarnLock = path.join(targetDir, 'yarn.lock');
-		const pnpmLock = path.join(targetDir, 'pnpm-lock.yaml');
-		if (fs.existsSync(yarnLock)) fs.unlinkSync(yarnLock);
-		if (fs.existsSync(pnpmLock)) fs.unlinkSync(pnpmLock);
-		log.step('🧹 Cleaned up lock files to ensure npm usage');
-	} catch {}
-
-	// Patch package name
-	log.step('📝 Updating project configuration...');
-	const pkg = path.join(targetDir, 'package.json');
-	if (fs.existsSync(pkg)) {
+	// SECTION • Prune
+	log.step('🧹 Pruning template...');
+	if (existingLicense !== null) {
+		fs.writeFileSync(licensePath, existingLicense);
+		log.info('Kept your existing LICENSE.');
+	}
+	for (const cargo of REPO_CARGO) rmrf(targetDir, cargo);
+	for (const lock of ['yarn.lock', 'package-lock.json', 'pnpm-lock.yaml']) rmrf(targetDir, lock);
+	CMS[cms].prune(targetDir);
+	log.ok(`Template pruned for ${CMS[cms].title}.`);
+
+	// SECTION • Patch package.json
+	const pkgPath = path.join(targetDir, 'package.json');
+	if (fs.existsSync(pkgPath)) {
 		try {
-			const json = JSON.parse(fs.readFileSync(pkg, 'utf8'));
-			json.name = projectName.toLowerCase();
-			fs.writeFileSync(pkg, JSON.stringify(json, null, 2));
-			log.ok('Project configuration updated!');
+			const json = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+			json.name = projectName;
+			json.version = '0.1.0';
+			delete json.repository;
+			delete json.author;
+			fs.writeFileSync(pkgPath, `${JSON.stringify(json, null, '\t')}\n`);
+			log.ok('package.json updated.');
 		} catch (e) {
 			log.warn(`Could not update package.json: ${e.message}`);
 		}
 	}
 
-	// Create .npmrc to ensure npm is used
-	try {
-		const npmrcPath = path.join(targetDir, '.npmrc');
-		fs.writeFileSync(npmrcPath, 'package-lock=true\n');
-		log.step('📝 Created .npmrc to ensure npm usage');
-	} catch (e) {
-		log.warn(`Could not create .npmrc: ${e.message}`);
-	}
-
-	if (doGit) {
+	// SECTION • Git
+	if (doGit && !hadGit) {
 		try {
-			log.step('🔧 Initializing git repository...');
+			log.step('🔧 Initialising git repository...');
 			execSync('git init', { cwd: targetDir, stdio: 'ignore' });
-
-			// Set default branch to main (not master)
 			execSync('git branch -M main', { cwd: targetDir, stdio: 'ignore' });
-
 			execSync('git add -A', { cwd: targetDir, stdio: 'ignore' });
-			execSync('git commit -m "chore: scaffold with tackl"', {
-				cwd: targetDir,
-				stdio: 'ignore',
-			});
-			log.ok('Git repository initialized!');
+			execSync('git commit -m "chore: scaffold with tackl" --no-verify', { cwd: targetDir, stdio: 'ignore' });
+			log.ok('Git repository initialised!');
 		} catch (e) {
 			log.warn(`Git init failed: ${e.message}`);
 		}
+	} else if (hadGit) {
+		log.info('Existing .git kept — review and commit the scaffold yourself.');
 	}
 
+	// SECTION • Install
 	if (doInstall) {
 		try {
-			log.step('📦 Installing dependencies with npm...');
-
-			// Disable Husky during installation to prevent Git issues
-			const originalEnv = { ...process.env };
-			process.env.HUSKY = '0';
-
-			execSync('npm install', { cwd: targetDir, stdio: 'inherit' });
-
-			// Restore environment
-			process.env = originalEnv;
-
-			// Try to fix audit issues automatically
-			try {
-				log.step('🔧 Fixing security vulnerabilities...');
-				execSync('npm audit fix', { cwd: targetDir, stdio: 'inherit' });
-				log.ok('Security vulnerabilities fixed!');
-			} catch (e) {
-				log.warn(
-					'Some vulnerabilities could not be automatically fixed.'
-				);
-				log.info(
-					'You can run "npm audit fix --force" manually if needed.'
-				);
-			}
-
-			log.ok('Dependencies installed successfully!');
+			log.step('📦 Installing dependencies with bun...');
+			execSync('bun install', { cwd: targetDir, stdio: 'inherit', env: { ...process.env, HUSKY: '0' } });
+			log.ok('Dependencies installed!');
 		} catch (e) {
 			log.warn(`Install failed: ${e.message}`);
 		}
@@ -262,14 +339,39 @@ ${pc.bold('Repository:')} https://github.com/12-studio/tackl
 		log.info('Skipped dependency install.');
 	}
 
-	const rel = path.relative(process.cwd(), targetDir) || '.';
-	console.log(
-		'\n' + pc.bold(pc.green('Success!')) + ' Project scaffolded.\n'
-	);
-	console.log(`  Next steps:`);
-	console.log(`  1) cd ${rel}`);
-	if (!doInstall) console.log(`  2) npm install`);
-	console.log(`  ${doInstall ? '2' : '3'}) npm run dev`);
+	// SECTION • Sanity project link
+	// NOTE • A Sanity scaffold isn't usable until a project id exists —
+	// sanity's own init logs in, creates/links a project and writes .env.
+	let sanityLinked = false;
+	if (cms === 'sanity' && process.stdout.isTTY) {
+		const { link } = await prompts({
+			type: 'confirm',
+			name: 'link',
+			message: 'Link a Sanity project now? (opens a browser login, writes .env)',
+			initial: true,
+		});
+		if (link) {
+			try {
+				execSync('bunx sanity@latest init --env .env', { cwd: targetDir, stdio: 'inherit' });
+				sanityLinked = true;
+				log.ok('Sanity project linked!');
+			} catch (e) {
+				log.warn(`sanity init did not complete: ${e.message}`);
+			}
+		}
+	}
+
+	console.log(`\n${pc.bold(pc.green('Success!'))} Project scaffolded.\n`);
+	console.log('  Next steps:');
+	let step = 1;
+	if (cms === 'sanity' && !sanityLinked) {
+		console.log(`  ${step++}) bunx sanity init --env .env   # create/link your Sanity project`);
+	} else if (cms !== 'sanity') {
+		console.log(`  ${step++}) cp .env.example .env   # then fill in your values`);
+	}
+	if (!doInstall) console.log(`  ${step++}) bun install`);
+	console.log(`  ${step++}) bun run dev   # a first-run setup wizard walks you through your theme`);
+	if (cms === 'sanity') console.log(`  ${step}) open http://localhost:3000/studio to start editing content`);
 }
 
 main().catch(e => {

package/package.json

@@ -1,10 +1,10 @@
 {
 	"name": "tackl",
-	"version": "1.0.10",
-	"description": "The ultimate Next.js starter kit with Waffl Grid system",
+	"version": "2.2.0",
+	"description": "Scaffold a Tackl project into the current directory — Next.js, styled-components, Waffl grid, DatoCMS/Sanity adapters",
 	"type": "module",
 	"bin": {
-		"tackl": "./bin/tackl.js"
+		"tackl": "bin/tackl.js"
 	},
 	"main": "index.js",
 	"scripts": {
@@ -27,7 +27,7 @@
 	},
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/12-studio/tackl"
+		"url": "git+https://github.com/12-studio/tackl.git"
 	},
 	"homepage": "https://github.com/12-studio/tackl",
 	"bugs": {