create-supaslidev 0.1.0

package/dist/index.js

@@ -0,0 +1,1675 @@
+import { Command } from "commander";
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { spawn } from "node:child_process";
+import * as p from "@clack/prompts";
+import ejs from "ejs";
+import pc from "picocolors";
+import { tmpdir } from "node:os";
+import { parse, parseDocument, stringify } from "yaml";
+import { IndentationText, Node, Project, SyntaxKind } from "ts-morph";
+
+//#region src/create.ts
+const CLI_VERSION$2 = "0.1.0";
+function createSafeSpinner() {
+	if (process.stdout.isTTY && process.stdin.isTTY) {
+		const spinner = p.spinner();
+		return {
+			start: (msg) => spinner.start(msg),
+			stop: (msg) => spinner.stop(msg),
+			message: (msg) => spinner.message(msg)
+		};
+	}
+	return {
+		start: () => {},
+		stop: () => {},
+		message: () => {}
+	};
+}
+const templatesDir = join(dirname(fileURLToPath(import.meta.url)), "..", "templates");
+const createdPaths = [];
+function trackPath(path) {
+	createdPaths.push(path);
+}
+function cleanup() {
+	for (const path of createdPaths.reverse()) try {
+		if (existsSync(path)) rmSync(path, {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+}
+async function renderTemplate(templatePath, data) {
+	return ejs.renderFile(templatePath, data);
+}
+function getOutputFileName(templateFileName) {
+	const name = templateFileName.replace(".ejs", "");
+	if (name === "gitignore") return ".gitignore";
+	if (name === "npmrc") return ".npmrc";
+	return name;
+}
+function runCommand(command, args, cwd) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			cwd,
+			stdio: "inherit",
+			shell: true
+		});
+		child.on("error", reject);
+		child.on("close", (code) => {
+			if (code === 0) resolve();
+			else reject(/* @__PURE__ */ new Error(`Command "${command} ${args.join(" ")}" exited with code ${code}`));
+		});
+	});
+}
+async function renderWorkspaceTemplates(targetDir, templateName, data) {
+	const templateDir = join(templatesDir, templateName);
+	if (!existsSync(templateDir)) throw new Error(`Template "${templateName}" not found`);
+	await renderTemplatesRecursively(templateDir, targetDir, data);
+}
+async function renderTemplatesRecursively(sourceDir, targetDir, data) {
+	const entries = readdirSync(sourceDir);
+	for (const entry of entries) {
+		const sourcePath = join(sourceDir, entry);
+		if (statSync(sourcePath).isDirectory()) {
+			const subTargetDir = join(targetDir, entry);
+			mkdirSync(subTargetDir, { recursive: true });
+			await renderTemplatesRecursively(sourcePath, subTargetDir, data);
+		} else if (entry.endsWith(".ejs")) writeFileSync(join(targetDir, getOutputFileName(entry)), await renderTemplate(sourcePath, data), "utf-8");
+	}
+}
+function createDirectoryStructure(targetDir) {
+	for (const dir of [
+		"presentations",
+		"packages",
+		"scripts"
+	]) {
+		const fullPath = join(targetDir, dir);
+		mkdirSync(fullPath, { recursive: true });
+		trackPath(fullPath);
+	}
+}
+async function createPresentation(targetDir, presentationName) {
+	const presentationDir = join(targetDir, "presentations", presentationName);
+	mkdirSync(presentationDir, { recursive: true });
+	trackPath(presentationDir);
+	const packageJson = {
+		name: `@supaslidev/${presentationName}`,
+		private: true,
+		type: "module",
+		scripts: {
+			build: "slidev build",
+			dev: "slidev --open",
+			export: "slidev export"
+		},
+		dependencies: {
+			"@slidev/cli": "catalog:",
+			"@slidev/theme-default": "catalog:",
+			"@slidev/theme-seriph": "catalog:",
+			"@slidev/theme-apple-basic": "catalog:",
+			"@supaslidev/shared": "workspace:*",
+			vue: "catalog:"
+		},
+		devDependencies: {}
+	};
+	writeFileSync(join(presentationDir, "package.json"), JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+	const slidesContent = `---
+theme: default
+title: ${presentationName}
+addons:
+  - '@supaslidev/shared'
+info: |
+  A new Slidev presentation
+class: text-center
+transition: slide-left
+mdc: true
+---
+
+# ${presentationName}
+
+Welcome to your new presentation
+
+---
+
+# Slide 2
+
+Add your content here
+
+---
+
+# Learn More
+
+[Slidev Documentation](https://sli.dev/)
+`;
+	writeFileSync(join(presentationDir, "slides.md"), slidesContent, "utf-8");
+	writeFileSync(join(presentationDir, ".gitignore"), "node_modules\ndist\n.slidev\n", "utf-8");
+	writeFileSync(join(presentationDir, ".npmrc"), "shamefully-hoist=true\n", "utf-8");
+}
+function createScripts(targetDir) {
+	writeFileSync(join(join(targetDir, "scripts"), "dev-presentation.mjs"), `#!/usr/bin/env node
+
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rootDir = join(__dirname, '..');
+const presentationsDir = join(rootDir, 'presentations');
+
+function getPresentations() {
+  if (!existsSync(presentationsDir)) {
+    return [];
+  }
+
+  return readdirSync(presentationsDir)
+    .filter((name) => {
+      const fullPath = join(presentationsDir, name);
+      return statSync(fullPath).isDirectory() && existsSync(join(fullPath, 'slides.md'));
+    })
+    .sort();
+}
+
+function printUsage(presentations) {
+  console.error('Usage: pnpm dev <presentation-name>');
+  console.error('\\nAvailable presentations:');
+
+  if (presentations.length === 0) {
+    console.error('  No presentations found');
+  } else {
+    presentations.forEach((name) => {
+      console.error(\`  \${name}\`);
+    });
+  }
+}
+
+function runDev(name) {
+  const packageName = \`@supaslidev/\${name}\`;
+
+  console.log(\`\\nStarting dev server for \${name}...\\n\`);
+
+  const pnpm = spawn('pnpm', ['--filter', packageName, 'dev'], {
+    cwd: rootDir,
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  pnpm.on('error', (err) => {
+    console.error(\`Failed to start dev server: \${err.message}\`);
+    process.exit(1);
+  });
+
+  pnpm.on('close', (code) => {
+    process.exit(code ?? 0);
+  });
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const name = args[0];
+  const presentations = getPresentations();
+
+  if (!name) {
+    console.error('Error: Presentation name is required');
+    printUsage(presentations);
+    process.exit(1);
+  }
+
+  if (!presentations.includes(name)) {
+    console.error(\`Error: Presentation "\${name}" not found\`);
+    printUsage(presentations);
+    process.exit(1);
+  }
+
+  runDev(name);
+}
+
+main();
+`, "utf-8");
+}
+function createSharedPackage(targetDir) {
+	const sharedDir = join(targetDir, "packages", "shared");
+	mkdirSync(sharedDir, { recursive: true });
+	trackPath(sharedDir);
+	for (const subdir of [
+		"components",
+		"layouts",
+		"styles"
+	]) {
+		const fullPath = join(sharedDir, subdir);
+		mkdirSync(fullPath, { recursive: true });
+		trackPath(fullPath);
+	}
+	writeFileSync(join(sharedDir, "package.json"), JSON.stringify({
+		name: "@supaslidev/shared",
+		private: true,
+		type: "module",
+		keywords: ["slidev-addon", "slidev"],
+		dependencies: { vue: "catalog:" }
+	}, null, 2) + "\n", "utf-8");
+	writeFileSync(join(sharedDir, "components", "SharedBadge.vue"), `<template>
+  <span class="shared-badge">
+    <slot />
+  </span>
+</template>
+
+<style scoped>
+.shared-badge {
+  display: inline-block;
+  padding: 0.25rem 0.5rem;
+  border-radius: 0.25rem;
+  background-color: var(--slidev-theme-primary, #3b82f6);
+  color: white;
+  font-size: 0.875rem;
+  font-weight: 500;
+}
+</style>
+`, "utf-8");
+	writeFileSync(join(sharedDir, "README.md"), `# @supaslidev/shared
+
+Shared components, layouts, and styles for your Slidev presentations.
+
+## Usage
+
+This package is configured as a Slidev addon. Components in the \`components\` directory are automatically available in all presentations that include this addon.
+
+## Structure
+
+- \`components/\` - Shared Vue components
+- \`layouts/\` - Custom slide layouts
+- \`styles/\` - Global styles
+`, "utf-8");
+	writeFileSync(join(sharedDir, "tsconfig.json"), JSON.stringify({
+		compilerOptions: {
+			target: "ESNext",
+			module: "ESNext",
+			moduleResolution: "bundler",
+			strict: true,
+			jsx: "preserve",
+			skipLibCheck: true
+		},
+		include: ["**/*.ts", "**/*.vue"]
+	}, null, 2) + "\n", "utf-8");
+}
+async function create(options = {}) {
+	const spinner = createSafeSpinner();
+	try {
+		let projectName;
+		let presentationName;
+		let initGit;
+		let runInstall;
+		if (options.name !== void 0 || options.presentation !== void 0) {
+			projectName = options.name ?? "my-presentations";
+			presentationName = options.presentation ?? "my-first-deck";
+			initGit = options.git ?? true;
+			runInstall = options.install ?? true;
+			if (!/^[a-z0-9-]+$/.test(projectName)) {
+				p.log.error("Project name must be lowercase alphanumeric with hyphens only");
+				process.exit(1);
+			}
+			if (projectName.startsWith("-") || projectName.endsWith("-")) {
+				p.log.error("Project name cannot start or end with a hyphen");
+				process.exit(1);
+			}
+			if (!/^[a-z0-9-]+$/.test(presentationName)) {
+				p.log.error("Presentation name must be lowercase alphanumeric with hyphens only");
+				process.exit(1);
+			}
+			if (presentationName.startsWith("-") || presentationName.endsWith("-")) {
+				p.log.error("Presentation name cannot start or end with a hyphen");
+				process.exit(1);
+			}
+		} else {
+			p.intro(pc.cyan("Create a new Supaslidev workspace"));
+			const projectNameResult = await p.text({
+				message: "What is your project name?",
+				placeholder: "my-presentations",
+				validate: (value) => {
+					if (!value.trim()) return "Project name is required";
+					if (!/^[a-z0-9-]+$/.test(value)) return "Project name must be lowercase alphanumeric with hyphens only";
+					if (value.startsWith("-") || value.endsWith("-")) return "Project name cannot start or end with a hyphen";
+				}
+			});
+			if (p.isCancel(projectNameResult)) {
+				p.cancel("Operation cancelled");
+				process.exit(0);
+			}
+			projectName = projectNameResult;
+			const presentationNameResult = await p.text({
+				message: "What is the name of your first presentation?",
+				placeholder: "my-first-deck",
+				initialValue: "my-first-deck",
+				validate: (value) => {
+					if (!value.trim()) return "Presentation name is required";
+					if (!/^[a-z0-9-]+$/.test(value)) return "Presentation name must be lowercase alphanumeric with hyphens only";
+					if (value.startsWith("-") || value.endsWith("-")) return "Presentation name cannot start or end with a hyphen";
+				}
+			});
+			if (p.isCancel(presentationNameResult)) {
+				p.cancel("Operation cancelled");
+				process.exit(0);
+			}
+			presentationName = presentationNameResult;
+			const initGitResult = await p.confirm({
+				message: "Initialize a git repository?",
+				initialValue: true
+			});
+			if (p.isCancel(initGitResult)) {
+				p.cancel("Operation cancelled");
+				process.exit(0);
+			}
+			initGit = initGitResult;
+			const runInstallResult = await p.confirm({
+				message: "Run pnpm install after scaffolding?",
+				initialValue: true
+			});
+			if (p.isCancel(runInstallResult)) {
+				p.cancel("Operation cancelled");
+				process.exit(0);
+			}
+			runInstall = runInstallResult;
+		}
+		const targetDir = join(process.cwd(), projectName);
+		if (existsSync(targetDir)) {
+			p.log.error(`Directory "${projectName}" already exists`);
+			process.exit(1);
+		}
+		mkdirSync(targetDir, { recursive: true });
+		trackPath(targetDir);
+		spinner.start("Creating workspace structure...");
+		createDirectoryStructure(targetDir);
+		const templateData = {
+			projectName,
+			presentationName,
+			description: `${projectName} - Slidev presentations monorepo`,
+			cliVersion: CLI_VERSION$2,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await renderWorkspaceTemplates(targetDir, options.template ?? "default", templateData);
+		spinner.message("Creating presentation...");
+		await createPresentation(targetDir, presentationName);
+		spinner.message("Creating shared package...");
+		createSharedPackage(targetDir);
+		spinner.message("Creating scripts...");
+		createScripts(targetDir);
+		spinner.stop("Workspace structure created");
+		if (initGit) {
+			spinner.start("Initializing git repository...");
+			try {
+				await runCommand("git", ["init"], targetDir);
+				spinner.stop("Git repository initialized");
+			} catch {
+				spinner.stop("Failed to initialize git repository");
+				p.log.warn("Git initialization failed. You can run \"git init\" manually.");
+			}
+		}
+		if (runInstall) {
+			spinner.start("Installing dependencies (this may take a while)...");
+			try {
+				await runCommand("pnpm", ["install"], targetDir);
+				spinner.stop("Dependencies installed");
+			} catch {
+				spinner.stop("Failed to install dependencies");
+				p.log.warn("Dependency installation failed. You can run \"pnpm install\" manually.");
+			}
+		}
+		createdPaths.length = 0;
+		p.outro(pc.green("Workspace created successfully!"));
+		console.log("");
+		console.log(pc.cyan("Next steps:"));
+		console.log(`  ${pc.dim("$")} cd ${projectName}`);
+		if (!runInstall) console.log(`  ${pc.dim("$")} pnpm install`);
+		console.log(`  ${pc.dim("$")} pnpm dev ${presentationName}`);
+		console.log("");
+	} catch (error) {
+		spinner.stop("Failed");
+		if (createdPaths.length > 0) {
+			p.log.warn("Cleaning up partial files...");
+			cleanup();
+			p.log.info("Cleanup complete");
+		}
+		const message = error instanceof Error ? error.message : "Unknown error occurred";
+		p.log.error(message);
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/state.ts
+const CLI_VERSION$1 = "0.1.0";
+const STATE_DIR = ".supaslidev";
+const STATE_FILE = "state.json";
+function getStatePath(workspaceDir) {
+	return join(workspaceDir, STATE_DIR, STATE_FILE);
+}
+function getStateDir(workspaceDir) {
+	return join(workspaceDir, STATE_DIR);
+}
+function createInitialState() {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		cliVersion: CLI_VERSION$1,
+		createdAt: now,
+		lastUpdatedAt: now,
+		appliedMigrations: []
+	};
+}
+function readState(workspaceDir) {
+	const statePath = getStatePath(workspaceDir);
+	if (!existsSync(statePath)) return null;
+	try {
+		const content = readFileSync(statePath, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return null;
+	}
+}
+function writeState(workspaceDir, state) {
+	const stateDir = getStateDir(workspaceDir);
+	const statePath = getStatePath(workspaceDir);
+	if (!existsSync(stateDir)) mkdirSync(stateDir, { recursive: true });
+	const updatedState = {
+		...state,
+		lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	writeFileSync(statePath, JSON.stringify(updatedState, null, 2) + "\n", "utf-8");
+}
+function initializeState(workspaceDir) {
+	const state = createInitialState();
+	writeState(workspaceDir, state);
+	return state;
+}
+function stateExists(workspaceDir) {
+	return existsSync(getStatePath(workspaceDir));
+}
+function addMigration(workspaceDir, migrationId) {
+	const state = readState(workspaceDir);
+	if (!state) throw new Error("State file not found. Is this a Supaslidev workspace?");
+	if (state.appliedMigrations.some((m) => m.id === migrationId)) return;
+	state.appliedMigrations.push({
+		id: migrationId,
+		appliedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	writeState(workspaceDir, state);
+}
+function hasMigration(workspaceDir, migrationId) {
+	const state = readState(workspaceDir);
+	if (!state) return false;
+	return state.appliedMigrations.some((m) => m.id === migrationId);
+}
+function updateCliVersion(workspaceDir) {
+	const state = readState(workspaceDir);
+	if (!state) throw new Error("State file not found. Is this a Supaslidev workspace?");
+	state.cliVersion = CLI_VERSION$1;
+	writeState(workspaceDir, state);
+}
+function findWorkspaceRoot(startDir = process.cwd()) {
+	let currentDir = startDir;
+	while (currentDir !== dirname(currentDir)) {
+		if (stateExists(currentDir)) return currentDir;
+		currentDir = dirname(currentDir);
+	}
+	return null;
+}
+function addImportedPresentation(workspaceDir, presentation) {
+	const state = readState(workspaceDir);
+	if (!state) throw new Error("State file not found. Is this a Supaslidev workspace?");
+	if (!state.importedPresentations) state.importedPresentations = [];
+	const existingIndex = state.importedPresentations.findIndex((p) => p.name === presentation.name);
+	if (existingIndex >= 0) state.importedPresentations[existingIndex] = presentation;
+	else state.importedPresentations.push(presentation);
+	writeState(workspaceDir, state);
+}
+function getImportedPresentations(workspaceDir) {
+	return readState(workspaceDir)?.importedPresentations ?? [];
+}
+function removeImportedPresentation(workspaceDir, name) {
+	const state = readState(workspaceDir);
+	if (!state) throw new Error("State file not found. Is this a Supaslidev workspace?");
+	if (!state.importedPresentations) return;
+	state.importedPresentations = state.importedPresentations.filter((p) => p.name !== name);
+	writeState(workspaceDir, state);
+}
+
+//#endregion
+//#region src/migrations/manifest.ts
+const MIGRATIONS_MANIFEST_FILE = "migrations.json";
+function readManifest(migrationsDir) {
+	const manifestPath = join(migrationsDir, MIGRATIONS_MANIFEST_FILE);
+	if (!existsSync(manifestPath)) return null;
+	const content = readFileSync(manifestPath, "utf-8");
+	return JSON.parse(content);
+}
+function writeManifest(migrationsDir, manifest) {
+	writeFileSync(join(migrationsDir, MIGRATIONS_MANIFEST_FILE), JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+}
+function createEmptyManifest() {
+	return {
+		version: "1.0.0",
+		migrations: []
+	};
+}
+function validateManifest(manifest) {
+	const errors = [];
+	if (!manifest.version) errors.push("Manifest missing version field");
+	if (!Array.isArray(manifest.migrations)) {
+		errors.push("Manifest migrations field must be an array");
+		return errors;
+	}
+	const ids = /* @__PURE__ */ new Set();
+	for (const migration of manifest.migrations) {
+		if (!migration.id) {
+			errors.push("Migration entry missing id field");
+			continue;
+		}
+		if (ids.has(migration.id)) errors.push(`Duplicate migration id: ${migration.id}`);
+		ids.add(migration.id);
+		if (!migration.description) errors.push(`Migration ${migration.id} missing description field`);
+		if (!migration.version) errors.push(`Migration ${migration.id} missing version field`);
+		if (migration.dependencies) {
+			for (const dep of migration.dependencies) if (!ids.has(dep)) {
+				if (!manifest.migrations.some((m) => m.id === dep)) errors.push(`Migration ${migration.id} has unknown dependency: ${dep}`);
+			}
+		}
+	}
+	return errors;
+}
+function getMigrationOrder(manifest) {
+	const visited = /* @__PURE__ */ new Set();
+	const order = [];
+	const migrationMap = new Map(manifest.migrations.map((m) => [m.id, m]));
+	function visit(id, path) {
+		if (visited.has(id)) return;
+		if (path.has(id)) throw new Error(`Circular dependency detected involving migration: ${id}`);
+		const migration = migrationMap.get(id);
+		if (!migration) return;
+		path.add(id);
+		for (const dep of migration.dependencies ?? []) visit(dep, path);
+		path.delete(id);
+		visited.add(id);
+		order.push(id);
+	}
+	for (const migration of manifest.migrations) visit(migration.id, /* @__PURE__ */ new Set());
+	return order;
+}
+
+//#endregion
+//#region src/version.ts
+const CLI_VERSION = "0.1.0";
+const PACKAGE_NAME = "@supaslidev/cli";
+const CACHE_DIR = join(tmpdir(), "supaslidev-cli");
+const CACHE_FILE = join(CACHE_DIR, "version-cache.json");
+const CACHE_TTL_MS = 1440 * 60 * 1e3;
+function compareVersions(current, latest) {
+	const parseVersion = (v) => v.replace(/^v/, "").split(".").map((n) => parseInt(n, 10) || 0);
+	const currentParts = parseVersion(current);
+	const latestParts = parseVersion(latest);
+	for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+		const curr = currentParts[i] ?? 0;
+		const lat = latestParts[i] ?? 0;
+		if (lat > curr) return true;
+		if (lat < curr) return false;
+	}
+	return false;
+}
+function readCache() {
+	try {
+		if (!existsSync(CACHE_FILE)) return null;
+		const data = JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+		if (Date.now() - data.checkedAt > CACHE_TTL_MS) return null;
+		return data;
+	} catch {
+		return null;
+	}
+}
+function writeCache(latestVersion) {
+	try {
+		if (!existsSync(CACHE_DIR)) mkdirSync(CACHE_DIR, { recursive: true });
+		const cache = {
+			latestVersion,
+			checkedAt: Date.now()
+		};
+		writeFileSync(CACHE_FILE, JSON.stringify(cache));
+	} catch {}
+}
+async function fetchLatestVersion() {
+	try {
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), 5e3);
+		const response = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}`, { signal: controller.signal });
+		clearTimeout(timeoutId);
+		if (!response.ok) return null;
+		const version = (await response.json())["dist-tags"].latest;
+		writeCache(version);
+		return version;
+	} catch {
+		return null;
+	}
+}
+function getCachedLatestVersion() {
+	return readCache()?.latestVersion ?? null;
+}
+async function checkForUpdates() {
+	const latestVersion = await fetchLatestVersion();
+	return {
+		currentVersion: CLI_VERSION,
+		latestVersion,
+		updateAvailable: latestVersion ? compareVersions(CLI_VERSION, latestVersion) : false
+	};
+}
+function checkForUpdatesCached() {
+	const latestVersion = getCachedLatestVersion();
+	return {
+		currentVersion: CLI_VERSION,
+		latestVersion,
+		updateAvailable: latestVersion ? compareVersions(CLI_VERSION, latestVersion) : false
+	};
+}
+
+//#endregion
+//#region src/commands/status.ts
+function getPendingMigrationsCount(workspaceDir) {
+	const manifest = readManifest(join(workspaceDir, ".supaslidev", "migrations"));
+	if (!manifest) return 0;
+	return manifest.migrations.filter((m) => !hasMigration(workspaceDir, m.id)).length;
+}
+function getAllPresentations(workspaceDir) {
+	const presentationsDir = join(workspaceDir, "presentations");
+	if (!existsSync(presentationsDir)) return [];
+	return readdirSync(presentationsDir).filter((name) => {
+		const fullPath = join(presentationsDir, name);
+		return statSync(fullPath).isDirectory() && existsSync(join(fullPath, "slides.md"));
+	}).sort();
+}
+async function getStatus(workspaceDir) {
+	const resolvedDir = workspaceDir ?? findWorkspaceRoot() ?? process.cwd();
+	const state = readState(resolvedDir);
+	const latestVersion = await fetchLatestVersion();
+	const updateAvailable = latestVersion ? compareVersions(CLI_VERSION, latestVersion) : false;
+	const importedPresentations = getImportedPresentations(resolvedDir);
+	const importedNames = new Set(importedPresentations.map((p) => p.name));
+	const nativePresentations = getAllPresentations(resolvedDir).filter((name) => !importedNames.has(name));
+	return {
+		cliVersion: CLI_VERSION,
+		stateVersion: state?.cliVersion ?? null,
+		createdAt: state?.createdAt ?? null,
+		lastUpdatedAt: state?.lastUpdatedAt ?? null,
+		pendingMigrations: state ? getPendingMigrationsCount(resolvedDir) : 0,
+		latestVersion,
+		updateAvailable,
+		nativePresentations,
+		importedPresentations
+	};
+}
+function formatDate(isoDate) {
+	return new Date(isoDate).toLocaleDateString("en-US", {
+		year: "numeric",
+		month: "short",
+		day: "numeric",
+		hour: "2-digit",
+		minute: "2-digit"
+	});
+}
+function formatStatus(status) {
+	const lines = [];
+	lines.push(pc.bold("Supaslidev Status"));
+	lines.push("─".repeat(40));
+	lines.push("");
+	lines.push(`${pc.dim("CLI Version:")}      ${status.cliVersion}`);
+	if (status.stateVersion) lines.push(`${pc.dim("State Version:")}    ${status.stateVersion}`);
+	else lines.push(`${pc.dim("State Version:")}    ${pc.yellow("Not initialized")}`);
+	lines.push("");
+	if (status.createdAt) lines.push(`${pc.dim("Created:")}          ${formatDate(status.createdAt)}`);
+	if (status.lastUpdatedAt) lines.push(`${pc.dim("Last Updated:")}     ${formatDate(status.lastUpdatedAt)}`);
+	lines.push("");
+	if (status.pendingMigrations > 0) lines.push(`${pc.dim("Pending Migrations:")} ${pc.yellow(String(status.pendingMigrations))}`);
+	else lines.push(`${pc.dim("Pending Migrations:")} ${pc.green("0")}`);
+	lines.push("");
+	lines.push(pc.bold("Presentations"));
+	lines.push("─".repeat(40));
+	lines.push("");
+	lines.push(pc.dim("Native:"));
+	if (status.nativePresentations.length === 0) lines.push("  No native presentations");
+	else for (const name of status.nativePresentations) lines.push(`  ${name}`);
+	lines.push("");
+	lines.push(pc.dim("Imported:"));
+	if (status.importedPresentations.length === 0) lines.push("  No imported presentations");
+	else for (const presentation of status.importedPresentations) {
+		lines.push(`  ${pc.bold(presentation.name)}`);
+		lines.push(`    ${pc.dim("Source:")} ${presentation.sourcePath}`);
+		lines.push(`    ${pc.dim("Imported:")} ${formatDate(presentation.importedAt)}`);
+	}
+	lines.push("");
+	if (status.updateAvailable && status.latestVersion) {
+		lines.push(pc.yellow(`Update available: ${status.cliVersion} → ${status.latestVersion}`));
+		lines.push(pc.dim("  Run `pnpm add -g @supaslidev/cli` to update"));
+	} else if (status.latestVersion) lines.push(pc.green("✓ CLI is up to date"));
+	else lines.push(pc.dim("Could not check for updates"));
+	return lines.join("\n");
+}
+async function status(workspaceDir) {
+	const result = await getStatus(workspaceDir);
+	console.log(formatStatus(result));
+}
+
+//#endregion
+//#region src/migrations/backup.ts
+const BACKUP_DIR = ".supaslidev/backups";
+const BACKUP_METADATA_FILE = "backup.json";
+const EXCLUDED_PATTERNS = [
+	"node_modules",
+	".git",
+	".supaslidev/backups",
+	"dist",
+	".turbo",
+	".cache"
+];
+function getBackupDir(workspaceDir) {
+	return join(workspaceDir, BACKUP_DIR);
+}
+function getBackupPath(workspaceDir, backupId) {
+	return join(getBackupDir(workspaceDir), backupId);
+}
+function generateBackupId() {
+	return `backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").replace("Z", "")}`;
+}
+function shouldExclude(relativePath) {
+	return EXCLUDED_PATTERNS.some((pattern) => relativePath === pattern || relativePath.startsWith(`${pattern}/`));
+}
+function collectFiles(dir, baseDir) {
+	const files = [];
+	const entries = readdirSync(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const fullPath = join(dir, entry.name);
+		const relativePath = relative(baseDir, fullPath);
+		if (shouldExclude(relativePath)) continue;
+		if (entry.isDirectory()) files.push(...collectFiles(fullPath, baseDir));
+		else if (entry.isFile()) files.push(relativePath);
+	}
+	return files;
+}
+function createBackup(workspaceDir) {
+	const state = readState(workspaceDir);
+	if (!state) throw new Error("State file not found. Is this a Supaslidev workspace?");
+	const backupId = generateBackupId();
+	const backupPath = getBackupPath(workspaceDir, backupId);
+	mkdirSync(backupPath, { recursive: true });
+	const files = collectFiles(workspaceDir, workspaceDir);
+	for (const file of files) {
+		const sourcePath = join(workspaceDir, file);
+		const destPath = join(backupPath, "files", file);
+		const destDir = join(destPath, "..");
+		if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+		cpSync(sourcePath, destPath);
+	}
+	const metadata = {
+		backupId,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		workspaceDir,
+		cliVersion: state.cliVersion,
+		files
+	};
+	writeFileSync(join(backupPath, BACKUP_METADATA_FILE), JSON.stringify(metadata, null, 2) + "\n", "utf-8");
+	return backupId;
+}
+function restoreBackup(workspaceDir, backupId) {
+	const backupPath = getBackupPath(workspaceDir, backupId);
+	const metadataPath = join(backupPath, BACKUP_METADATA_FILE);
+	if (!existsSync(metadataPath)) throw new Error(`Backup not found: ${backupId}`);
+	const metadata = JSON.parse(readFileSync(metadataPath, "utf-8"));
+	for (const file of metadata.files) {
+		const sourcePath = join(backupPath, "files", file);
+		const destPath = join(workspaceDir, file);
+		if (existsSync(sourcePath)) {
+			const destDir = join(destPath, "..");
+			if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+			cpSync(sourcePath, destPath);
+		}
+	}
+}
+function deleteBackup(workspaceDir, backupId) {
+	const backupPath = getBackupPath(workspaceDir, backupId);
+	if (existsSync(backupPath)) rmSync(backupPath, {
+		recursive: true,
+		force: true
+	});
+}
+function listBackups(workspaceDir) {
+	const backupDir = getBackupDir(workspaceDir);
+	if (!existsSync(backupDir)) return [];
+	const entries = readdirSync(backupDir, { withFileTypes: true });
+	const backups = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const metadataPath = join(backupDir, entry.name, BACKUP_METADATA_FILE);
+		if (existsSync(metadataPath)) {
+			const metadata = JSON.parse(readFileSync(metadataPath, "utf-8"));
+			backups.push(metadata);
+		}
+	}
+	return backups.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+}
+function getBackupMetadata(workspaceDir, backupId) {
+	const metadataPath = join(getBackupPath(workspaceDir, backupId), BACKUP_METADATA_FILE);
+	if (!existsSync(metadataPath)) return null;
+	return JSON.parse(readFileSync(metadataPath, "utf-8"));
+}
+function backupExists(workspaceDir, backupId) {
+	return existsSync(join(getBackupPath(workspaceDir, backupId), BACKUP_METADATA_FILE));
+}
+
+//#endregion
+//#region src/migrations/journal.ts
+const JOURNAL_DIR = ".supaslidev";
+const JOURNAL_FILE = "migration-journal.json";
+function getJournalPath(workspaceDir) {
+	return join(workspaceDir, JOURNAL_DIR, JOURNAL_FILE);
+}
+function getJournalDir(workspaceDir) {
+	return join(workspaceDir, JOURNAL_DIR);
+}
+function ensureJournalDir(workspaceDir) {
+	const journalDir = getJournalDir(workspaceDir);
+	if (!existsSync(journalDir)) mkdirSync(journalDir, { recursive: true });
+}
+function readJournal(workspaceDir) {
+	const journalPath = getJournalPath(workspaceDir);
+	if (!existsSync(journalPath)) return { entries: [] };
+	const content = readFileSync(journalPath, "utf-8");
+	return JSON.parse(content);
+}
+function writeJournal(workspaceDir, journal) {
+	ensureJournalDir(workspaceDir);
+	writeFileSync(getJournalPath(workspaceDir), JSON.stringify(journal, null, 2) + "\n", "utf-8");
+}
+function addJournalEntry(workspaceDir, entry) {
+	const journal = readJournal(workspaceDir);
+	journal.entries.push(entry);
+	writeJournal(workspaceDir, journal);
+}
+function createJournalEntry(migrationId, backupId, success, rolledBack = false, error) {
+	return {
+		migrationId,
+		appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		backupId,
+		success,
+		rolledBack,
+		error: error?.message
+	};
+}
+function getJournalEntries(workspaceDir) {
+	return readJournal(workspaceDir).entries;
+}
+function getLastSuccessfulEntry(workspaceDir) {
+	const successful = getJournalEntries(workspaceDir).filter((e) => e.success && !e.rolledBack);
+	return successful.length > 0 ? successful[successful.length - 1] : null;
+}
+function getMigrationHistory(workspaceDir, migrationId) {
+	return getJournalEntries(workspaceDir).filter((e) => e.migrationId === migrationId);
+}
+function wasMigrationSuccessful(workspaceDir, migrationId) {
+	const history = getMigrationHistory(workspaceDir, migrationId);
+	const lastEntry = history[history.length - 1];
+	return lastEntry?.success === true && !lastEntry.rolledBack;
+}
+function getFailedMigrations(workspaceDir) {
+	return getJournalEntries(workspaceDir).filter((e) => !e.success || e.rolledBack);
+}
+function clearJournal(workspaceDir) {
+	writeJournal(workspaceDir, { entries: [] });
+}
+
+//#endregion
+//#region src/migrations/runner.ts
+function loadMigration(migrations, id) {
+	return migrations.find((m) => m.id === id) ?? null;
+}
+function dryRun(options) {
+	const { workspaceDir, migrationsDir } = options;
+	const results = [];
+	const manifest = readManifest(migrationsDir);
+	if (!manifest) throw new Error(`No migrations.json found in ${migrationsDir}`);
+	const errors = validateManifest(manifest);
+	if (errors.length > 0) throw new Error(`Invalid migrations.json:\n${errors.join("\n")}`);
+	const order = getMigrationOrder(manifest);
+	const manifestMap = new Map(manifest.migrations.map((m) => [m.id, m]));
+	for (const id of order) {
+		const entry = manifestMap.get(id);
+		if (!entry) continue;
+		const alreadyApplied = hasMigration(workspaceDir, id);
+		results.push({
+			migrationId: id,
+			description: entry.description,
+			wouldApply: !alreadyApplied,
+			alreadyApplied,
+			breaking: entry.breaking
+		});
+	}
+	return results;
+}
+function formatDryRunOutput(results) {
+	const lines = [];
+	lines.push("Migration Preview (Dry Run)");
+	lines.push("=".repeat(50));
+	lines.push("");
+	const toApply = results.filter((r) => r.wouldApply);
+	const alreadyApplied = results.filter((r) => r.alreadyApplied);
+	if (toApply.length === 0) lines.push("No migrations to apply. Workspace is up to date.");
+	else {
+		lines.push(`Migrations to apply: ${toApply.length}`);
+		lines.push("");
+		for (const result of toApply) {
+			const breakingTag = result.breaking ? " [BREAKING]" : "";
+			lines.push(`  → ${result.migrationId}${breakingTag}`);
+			lines.push(`    ${result.description}`);
+		}
+	}
+	if (alreadyApplied.length > 0) {
+		lines.push("");
+		lines.push(`Already applied: ${alreadyApplied.length}`);
+		for (const result of alreadyApplied) lines.push(`  ✓ ${result.migrationId}`);
+	}
+	lines.push("");
+	lines.push("Run with --apply to execute migrations.");
+	return lines.join("\n");
+}
+async function executeMigration(migration, context) {
+	try {
+		await migration.up(context);
+		return {
+			migrationId: migration.id,
+			success: true,
+			rolledBack: false
+		};
+	} catch (error) {
+		return {
+			migrationId: migration.id,
+			success: false,
+			error: error instanceof Error ? error : new Error(String(error)),
+			rolledBack: false
+		};
+	}
+}
+async function run(options) {
+	const { workspaceDir, migrationsDir, apply = false, migrations = [], migrationOptions = {} } = options;
+	if (!apply) return {
+		success: true,
+		applied: [],
+		skipped: dryRun(options).filter((r) => r.alreadyApplied).map((r) => r.migrationId),
+		failed: null,
+		backupId: null,
+		rolledBack: false
+	};
+	const manifest = readManifest(migrationsDir);
+	if (!manifest) throw new Error(`No migrations.json found in ${migrationsDir}`);
+	const errors = validateManifest(manifest);
+	if (errors.length > 0) throw new Error(`Invalid migrations.json:\n${errors.join("\n")}`);
+	const order = getMigrationOrder(manifest);
+	const toApply = order.filter((id) => !hasMigration(workspaceDir, id));
+	if (toApply.length === 0) return {
+		success: true,
+		applied: [],
+		skipped: order,
+		failed: null,
+		backupId: null,
+		rolledBack: false
+	};
+	const backupId = createBackup(workspaceDir);
+	const state = readState(workspaceDir);
+	if (!state) throw new Error("State file not found. Is this a Supaslidev workspace?");
+	const baseContext = {
+		workspaceDir,
+		state,
+		backupPath: backupId ? join(workspaceDir, ".supaslidev", "backups", backupId) : null
+	};
+	const applied = [];
+	let failed = null;
+	let rolledBack = false;
+	for (const id of toApply) {
+		const migration = loadMigration(migrations, id);
+		if (!migration) {
+			failed = {
+				migrationId: id,
+				success: false,
+				error: /* @__PURE__ */ new Error(`Migration implementation not found: ${id}`),
+				rolledBack: false
+			};
+			break;
+		}
+		const result = await executeMigration(migration, {
+			...baseContext,
+			options: migrationOptions[id]
+		});
+		if (result.success) {
+			applied.push(result);
+			addMigration(workspaceDir, id);
+			addJournalEntry(workspaceDir, createJournalEntry(id, backupId, true, false));
+		} else {
+			failed = result;
+			addJournalEntry(workspaceDir, createJournalEntry(id, backupId, false, false, result.error));
+			break;
+		}
+	}
+	if (failed) {
+		restoreBackup(workspaceDir, backupId);
+		rolledBack = true;
+		addJournalEntry(workspaceDir, createJournalEntry(failed.migrationId, backupId, false, true, failed.error));
+		failed.rolledBack = true;
+	} else deleteBackup(workspaceDir, backupId);
+	const skipped = order.filter((id) => !toApply.includes(id) || !applied.some((a) => a.migrationId === id) && failed?.migrationId !== id);
+	return {
+		success: !failed,
+		applied,
+		skipped,
+		failed,
+		backupId: failed ? backupId : null,
+		rolledBack
+	};
+}
+function formatRunOutput(result) {
+	const lines = [];
+	if (result.success) {
+		lines.push("Migration Complete");
+		lines.push("=".repeat(50));
+		lines.push("");
+		if (result.applied.length === 0) lines.push("No migrations were applied. Workspace is up to date.");
+		else {
+			lines.push(`Applied ${result.applied.length} migration(s):`);
+			for (const migration of result.applied) lines.push(`  ✓ ${migration.migrationId}`);
+		}
+		if (result.skipped.length > 0) {
+			lines.push("");
+			lines.push(`Skipped ${result.skipped.length} (already applied):`);
+			for (const id of result.skipped) lines.push(`  - ${id}`);
+		}
+	} else {
+		lines.push("Migration Failed");
+		lines.push("=".repeat(50));
+		lines.push("");
+		if (result.failed) {
+			lines.push(`Failed migration: ${result.failed.migrationId}`);
+			if (result.failed.error) lines.push(`Error: ${result.failed.error.message}`);
+		}
+		if (result.rolledBack) {
+			lines.push("");
+			lines.push("Workspace has been restored from backup.");
+			if (result.backupId) lines.push(`Backup preserved: ${result.backupId}`);
+		}
+		if (result.applied.length > 0) {
+			lines.push("");
+			lines.push(`Rolled back ${result.applied.length} migration(s):`);
+			for (const migration of result.applied) lines.push(`  ↩ ${migration.migrationId}`);
+		}
+	}
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/migrations/loader.ts
+const MIGRATIONS = [];
+async function loadMigrations() {
+	return {
+		migrations: MIGRATIONS.map((entry) => ({
+			id: entry.id,
+			description: entry.description,
+			up: entry.module.up,
+			down: entry.module.down
+		})),
+		order: MIGRATIONS.map((entry) => entry.id)
+	};
+}
+async function getMigrationById(id) {
+	const { migrations } = await loadMigrations();
+	return migrations.find((m) => m.id === id) ?? null;
+}
+async function loadInteractiveMigration(id) {
+	const entry = MIGRATIONS.find((m) => m.id === id);
+	if (!entry) return null;
+	return {
+		migration: {
+			id: entry.id,
+			description: entry.description,
+			up: entry.module.up,
+			down: entry.module.down
+		},
+		getAffectedPresentations: entry.module.getAffectedPresentations
+	};
+}
+
+//#endregion
+//#region src/prompts.ts
+async function promptForCatalogSelection(presentations) {
+	p.intro(pc.cyan("Catalog Conversion Selection"));
+	p.note(`${pc.bold("Select presentations to convert to catalog: references")}\n\nSelected presentations will use ${pc.green("catalog:")} (managed versions)\nUnselected presentations will use ${pc.yellow("^52.11.3")} (pinned version)\n\n${pc.dim("Controls:")} ${pc.bold("Space")} ${pc.dim("toggle |")} ${pc.bold("a")} ${pc.dim("toggle all |")} ${pc.bold("Enter")} ${pc.dim("confirm")}`, "Migration Options");
+	const options = presentations.map((pres) => ({
+		value: pres.name,
+		label: pres.name,
+		hint: `currently ${pres.currentVersion}`
+	}));
+	const selected = await p.multiselect({
+		message: "Which presentations should use catalog: references?",
+		options,
+		initialValues: presentations.map((p) => p.name),
+		required: false
+	});
+	if (p.isCancel(selected)) {
+		p.cancel("Migration cancelled");
+		return {
+			selectedForCatalog: [],
+			cancelled: true
+		};
+	}
+	const selectedCount = selected.length;
+	const pinnedCount = presentations.length - selectedCount;
+	if (selectedCount > 0) p.log.success(`${selectedCount} presentation(s) will use catalog: references`);
+	if (pinnedCount > 0) p.log.info(`${pinnedCount} presentation(s) will use pinned ^52.11.3`);
+	return {
+		selectedForCatalog: selected,
+		cancelled: false
+	};
+}
+
+//#endregion
+//#region src/commands/migrate.ts
+async function getMigrateResult(options = {}) {
+	const workspaceDir = findWorkspaceRoot();
+	if (!workspaceDir) return {
+		success: false,
+		dryRun: !options.apply,
+		migrationsToApply: 0,
+		migrationsApplied: 0,
+		output: "Not a Supaslidev workspace. No .supaslidev/state.json found."
+	};
+	const migrationsDir = join(workspaceDir, ".supaslidev", "migrations");
+	if (options.apply) {
+		const { migrations } = await loadMigrations();
+		const migrationOptions = {};
+		const slidev51to52 = await loadInteractiveMigration("slidev-51-to-52");
+		if (slidev51to52?.getAffectedPresentations) {
+			const affected = slidev51to52.getAffectedPresentations(workspaceDir);
+			if (affected.length > 0) {
+				const selectionResult = await promptForCatalogSelection(affected);
+				if (selectionResult.cancelled) return {
+					success: false,
+					dryRun: false,
+					migrationsToApply: 0,
+					migrationsApplied: 0,
+					output: "Migration cancelled by user."
+				};
+				migrationOptions["slidev-51-to-52"] = {
+					interactive: true,
+					selectedForCatalog: selectionResult.selectedForCatalog
+				};
+			}
+		}
+		const result = await run({
+			workspaceDir,
+			migrationsDir,
+			apply: true,
+			migrations,
+			migrationOptions
+		});
+		return {
+			success: result.success,
+			dryRun: false,
+			migrationsToApply: result.applied.length + (result.failed ? 1 : 0),
+			migrationsApplied: result.applied.length,
+			output: formatRunOutput(result)
+		};
+	}
+	try {
+		const results = dryRun({
+			workspaceDir,
+			migrationsDir
+		});
+		return {
+			success: true,
+			dryRun: true,
+			migrationsToApply: results.filter((r) => r.wouldApply).length,
+			migrationsApplied: 0,
+			output: formatDryRunOutput(results)
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (message.includes("No migrations.json found")) return {
+			success: true,
+			dryRun: true,
+			migrationsToApply: 0,
+			migrationsApplied: 0,
+			output: "No migrations available. Workspace is up to date."
+		};
+		return {
+			success: false,
+			dryRun: true,
+			migrationsToApply: 0,
+			migrationsApplied: 0,
+			output: `Error: ${message}`
+		};
+	}
+}
+function formatMigrateOutput(result) {
+	const lines = [];
+	lines.push(pc.bold("Supaslidev Migrate"));
+	lines.push("─".repeat(40));
+	lines.push("");
+	if (result.dryRun) {
+		lines.push(pc.cyan("Mode: Dry Run (no changes will be made)"));
+		lines.push("");
+	}
+	lines.push(result.output);
+	if (!result.success) {
+		lines.push("");
+		lines.push(pc.red("✗ Migration failed"));
+	} else if (result.dryRun && result.migrationsToApply > 0) {
+		lines.push("");
+		lines.push(pc.yellow(`Run ${pc.bold("supaslidev migrate --apply")} to execute migrations.`));
+	} else if (!result.dryRun && result.migrationsApplied > 0) {
+		lines.push("");
+		lines.push(pc.green("✓ All migrations applied successfully"));
+	}
+	return lines.join("\n");
+}
+async function migrate(options = {}) {
+	const result = await getMigrateResult(options);
+	console.log(formatMigrateOutput(result));
+	if (!result.success) process.exit(1);
+}
+
+//#endregion
+//#region src/commands/update.ts
+async function getUpdateResult() {
+	const check = await checkForUpdates();
+	return {
+		currentVersion: check.currentVersion,
+		latestVersion: check.latestVersion,
+		updateAvailable: check.updateAvailable,
+		error: check.latestVersion === null ? "Could not reach npm registry" : null
+	};
+}
+function formatUpdateResult(result) {
+	const lines = [];
+	lines.push(pc.bold("Supaslidev Update Check"));
+	lines.push("─".repeat(40));
+	lines.push("");
+	lines.push(`${pc.dim("Current Version:")}  ${result.currentVersion}`);
+	if (result.error) {
+		lines.push("");
+		lines.push(pc.yellow(`⚠ ${result.error}`));
+		return lines.join("\n");
+	}
+	lines.push(`${pc.dim("Latest Version:")}   ${result.latestVersion}`);
+	lines.push("");
+	if (result.updateAvailable) {
+		lines.push(pc.yellow(`Update available: ${result.currentVersion} → ${result.latestVersion}`));
+		lines.push("");
+		lines.push(pc.bold("To update, run:"));
+		lines.push(`  ${pc.cyan(`npm install -g ${PACKAGE_NAME}`)}`);
+		lines.push("");
+		lines.push(pc.dim("or with pnpm:"));
+		lines.push(`  ${pc.cyan(`pnpm add -g ${PACKAGE_NAME}`)}`);
+	} else lines.push(pc.green("✓ You are using the latest version"));
+	return lines.join("\n");
+}
+async function update() {
+	const result = await getUpdateResult();
+	console.log(formatUpdateResult(result));
+	if (result.error) process.exit(1);
+}
+
+//#endregion
+//#region src/background-update.ts
+function startBackgroundUpdateCheck() {
+	const cached = checkForUpdatesCached();
+	if (cached.updateAvailable && cached.latestVersion) {
+		scheduleNotification(cached.latestVersion);
+		return;
+	}
+	fetchLatestVersion().then((latestVersion) => {
+		if (latestVersion && compareVersions(CLI_VERSION, latestVersion)) scheduleNotification(latestVersion);
+	}).catch(() => {});
+}
+function scheduleNotification(latestVersion) {
+	process.on("beforeExit", () => {
+		printUpdateNotification(latestVersion);
+	});
+}
+function printUpdateNotification(latestVersion) {
+	const border = "─".repeat(50);
+	console.log("");
+	console.log(pc.yellow(border));
+	console.log(pc.yellow(`  Update available: ${pc.dim(CLI_VERSION)} → ${pc.green(latestVersion)}`));
+	console.log(pc.yellow(`  Run ${pc.cyan(`npm install -g ${PACKAGE_NAME}`)} to update`));
+	console.log(pc.yellow(border));
+}
+
+//#endregion
+//#region src/cli.ts
+const program = new Command();
+program.name("create-supaslidev").description("CLI tool for scaffolding Supaslidev presentations").version("0.1.0");
+program.command("create", { isDefault: true }).description("Create a new Supaslidev workspace").option("-n, --name <name>", "Name of the workspace").option("-p, --presentation <name>", "Name of the first presentation").option("-t, --template <template>", "Template to use", "default").option("--git", "Initialize a git repository").option("--no-git", "Skip git initialization").option("--install", "Run pnpm install after scaffolding").option("--no-install", "Skip pnpm install").action(async (options) => {
+	await create(options);
+});
+program.command("status").description("Show project status and check for updates").action(async () => {
+	await status();
+});
+program.command("migrate").description("Run migrations to update the workspace").option("--apply", "Execute migrations (default is dry-run mode)").action(async (options) => {
+	await migrate(options);
+});
+program.command("update").description("Check for CLI updates").action(async () => {
+	await update();
+});
+async function run$1() {
+	startBackgroundUpdateCheck();
+	await program.parseAsync();
+}
+const scriptName = process.argv[1] ? basename(process.argv[1]) : "";
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href || scriptName === "cli.js") run$1().catch((err) => {
+	console.error(err);
+	process.exit(1);
+});
+
+//#endregion
+//#region src/transformers/json.ts
+function readJsonFile(filePath) {
+	const content = readFileSync(filePath, "utf-8");
+	return JSON.parse(content);
+}
+function writeJsonFile(filePath, data, indent = 2) {
+	writeFileSync(filePath, JSON.stringify(data, null, indent) + "\n", "utf-8");
+}
+function transformJson(filePath, transformer) {
+	const original = readJsonFile(filePath);
+	const transformed = transformer(structuredClone(original));
+	const changed = JSON.stringify(original) !== JSON.stringify(transformed);
+	if (changed) writeJsonFile(filePath, transformed);
+	return {
+		original,
+		transformed,
+		changed
+	};
+}
+function getJsonValue(data, path) {
+	if (path === "") return data;
+	const keys = path.split(".");
+	let current = data;
+	for (const key of keys) {
+		if (current === null || typeof current !== "object") return;
+		current = current[key];
+	}
+	return current;
+}
+function setJsonValue(data, path, value) {
+	const keys = path.split(".");
+	const result = structuredClone(data);
+	let current = result;
+	for (let i = 0; i < keys.length - 1; i++) {
+		const key = keys[i];
+		const nextKey = keys[i + 1];
+		const isNextKeyNumeric = /^\d+$/.test(nextKey);
+		if (Array.isArray(current)) {
+			const index = parseInt(key, 10);
+			if (isNaN(index)) throw new Error(`Cannot use non-numeric key "${key}" on array at path "${keys.slice(0, i).join(".")}"`);
+			if (current[index] === void 0 || current[index] === null || typeof current[index] !== "object") current[index] = isNextKeyNumeric ? [] : {};
+			current = current[index];
+		} else {
+			if (!(key in current) || current[key] === null || typeof current[key] !== "object") current[key] = isNextKeyNumeric ? [] : {};
+			else if (Array.isArray(current[key]) && !isNextKeyNumeric) throw new Error(`Cannot use non-numeric key "${nextKey}" on array at path "${keys.slice(0, i + 1).join(".")}"`);
+			current = current[key];
+		}
+	}
+	const finalKey = keys[keys.length - 1];
+	if (Array.isArray(current)) {
+		const index = parseInt(finalKey, 10);
+		if (isNaN(index)) throw new Error(`Cannot use non-numeric key "${finalKey}" on array`);
+		current[index] = value;
+	} else current[finalKey] = value;
+	return result;
+}
+function deleteJsonValue(data, path) {
+	const keys = path.split(".");
+	const result = structuredClone(data);
+	let current = result;
+	for (let i = 0; i < keys.length - 1; i++) {
+		const key = keys[i];
+		if (Array.isArray(current)) {
+			const index = parseInt(key, 10);
+			if (isNaN(index) || current[index] === void 0 || current[index] === null || typeof current[index] !== "object") return result;
+			current = current[index];
+		} else {
+			if (!(key in current) || current[key] === null || typeof current[key] !== "object") return result;
+			current = current[key];
+		}
+	}
+	const finalKey = keys[keys.length - 1];
+	if (Array.isArray(current)) {
+		const index = parseInt(finalKey, 10);
+		if (!isNaN(index) && index < current.length) current.splice(index, 1);
+	} else delete current[finalKey];
+	return result;
+}
+function mergeJson(target, source) {
+	const result = structuredClone(target);
+	for (const key of Object.keys(source)) {
+		const sourceValue = source[key];
+		const targetValue = result[key];
+		if (sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue)) result[key] = mergeJson(targetValue, sourceValue);
+		else result[key] = structuredClone(sourceValue);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/transformers/yaml.ts
+const defaultParseOptions = { keepSourceTokens: true };
+function readYamlFile(filePath) {
+	return parse(readFileSync(filePath, "utf-8"));
+}
+function writeYamlFile(filePath, data) {
+	writeFileSync(filePath, stringify(data), "utf-8");
+}
+function readYamlDocument(filePath) {
+	return parseDocument(readFileSync(filePath, "utf-8"), defaultParseOptions);
+}
+function writeYamlDocument(filePath, doc) {
+	writeFileSync(filePath, doc.toString(), "utf-8");
+}
+function transformYaml(filePath, transformer) {
+	const original = readYamlFile(filePath);
+	const transformed = transformer(structuredClone(original));
+	const changed = stringify(original) !== stringify(transformed);
+	if (changed) writeYamlFile(filePath, transformed);
+	return {
+		original,
+		transformed,
+		changed
+	};
+}
+function transformYamlDocument(filePath, transformer) {
+	const doc = readYamlDocument(filePath);
+	const originalContent = doc.toString();
+	transformer(doc);
+	const newContent = doc.toString();
+	const changed = originalContent !== newContent;
+	if (changed) writeFileSync(filePath, newContent, "utf-8");
+	return { changed };
+}
+function getYamlValue(data, path) {
+	const keys = path.split(".");
+	let current = data;
+	for (const key of keys) {
+		if (current === null || typeof current !== "object") return;
+		current = current[key];
+	}
+	return current;
+}
+function setYamlValue(data, path, value) {
+	const keys = path.split(".");
+	const result = structuredClone(data);
+	let current = result;
+	for (let i = 0; i < keys.length - 1; i++) {
+		const key = keys[i];
+		if (!(key in current) || typeof current[key] !== "object" || current[key] === null) current[key] = {};
+		current = current[key];
+	}
+	current[keys[keys.length - 1]] = value;
+	return result;
+}
+function deleteYamlValue(data, path) {
+	const keys = path.split(".");
+	const result = structuredClone(data);
+	let current = result;
+	for (let i = 0; i < keys.length - 1; i++) {
+		const key = keys[i];
+		if (!(key in current) || typeof current[key] !== "object" || current[key] === null) return result;
+		current = current[key];
+	}
+	delete current[keys[keys.length - 1]];
+	return result;
+}
+function mergeYaml(target, source) {
+	const result = structuredClone(target);
+	for (const key of Object.keys(source)) {
+		const sourceValue = source[key];
+		const targetValue = result[key];
+		if (sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue)) result[key] = mergeYaml(targetValue, sourceValue);
+		else result[key] = structuredClone(sourceValue);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/transformers/typescript.ts
+function createTransformer(filePath) {
+	const project = new Project({
+		useInMemoryFileSystem: false,
+		manipulationSettings: {
+			indentationText: IndentationText.TwoSpaces,
+			useTrailingCommas: true
+		}
+	});
+	const sourceFile = project.addSourceFileAtPath(filePath);
+	const originalContent = sourceFile.getFullText();
+	return {
+		project,
+		sourceFile,
+		save: () => {
+			const newContent = sourceFile.getFullText();
+			const changed = originalContent !== newContent;
+			if (changed) sourceFile.saveSync();
+			return {
+				changed,
+				originalContent,
+				newContent
+			};
+		}
+	};
+}
+function transformTypeScript(filePath, transformer) {
+	const { sourceFile, save } = createTransformer(filePath);
+	transformer(sourceFile);
+	return save();
+}
+function addImport(sourceFile, moduleSpecifier, namedImports) {
+	const existingImport = sourceFile.getImportDeclaration(moduleSpecifier);
+	if (existingImport) {
+		const existingNamedImports = existingImport.getNamedImports().map((n) => n.getName());
+		const newImports = namedImports.filter((n) => !existingNamedImports.includes(n));
+		if (newImports.length > 0) existingImport.addNamedImports(newImports);
+		return existingImport;
+	}
+	return sourceFile.addImportDeclaration({
+		moduleSpecifier,
+		namedImports
+	});
+}
+function removeImport(sourceFile, moduleSpecifier, namedImports) {
+	const importDecl = sourceFile.getImportDeclaration(moduleSpecifier);
+	if (!importDecl) return false;
+	if (!namedImports) {
+		importDecl.remove();
+		return true;
+	}
+	const existingNamedImports = importDecl.getNamedImports();
+	for (const namedImport of existingNamedImports) if (namedImports.includes(namedImport.getName())) namedImport.remove();
+	const hasNamedImports = importDecl.getNamedImports().length > 0;
+	const hasDefaultImport = !!importDecl.getDefaultImport();
+	const hasNamespaceImport = !!importDecl.getNamespaceImport();
+	if (!hasNamedImports && !hasDefaultImport && !hasNamespaceImport) importDecl.remove();
+	return true;
+}
+function addExport(sourceFile, moduleSpecifier, namedExports) {
+	const existingExport = sourceFile.getExportDeclarations().find((e) => e.getModuleSpecifierValue() === moduleSpecifier);
+	if (existingExport) {
+		const existingNamedExports = existingExport.getNamedExports().map((e) => e.getName());
+		const newExports = namedExports.filter((e) => !existingNamedExports.includes(e));
+		if (newExports.length > 0) existingExport.addNamedExports(newExports);
+		return existingExport;
+	}
+	return sourceFile.addExportDeclaration({
+		moduleSpecifier,
+		namedExports
+	});
+}
+function findObjectLiteral(sourceFile, variableName) {
+	const variable = sourceFile.getVariableDeclaration(variableName);
+	if (!variable) return;
+	const initializer = variable.getInitializer();
+	if (initializer?.getKind() === SyntaxKind.ObjectLiteralExpression) return initializer;
+}
+function findArrayLiteral(sourceFile, variableName) {
+	const variable = sourceFile.getVariableDeclaration(variableName);
+	if (!variable) return;
+	const initializer = variable.getInitializer();
+	if (initializer?.getKind() === SyntaxKind.ArrayLiteralExpression) return initializer;
+}
+function getObjectProperty(obj, propertyName) {
+	const property = obj.getProperty(propertyName);
+	if (property && Node.isPropertyAssignment(property)) return property;
+}
+function setObjectProperty(obj, propertyName, value) {
+	const existing = getObjectProperty(obj, propertyName);
+	if (existing) existing.setInitializer(value);
+	else obj.addPropertyAssignment({
+		name: propertyName,
+		initializer: value
+	});
+}
+function removeObjectProperty(obj, propertyName) {
+	const property = obj.getProperty(propertyName);
+	if (property) {
+		property.remove();
+		return true;
+	}
+	return false;
+}
+function addArrayElement(arr, element) {
+	arr.addElement(element);
+}
+function removeArrayElement(arr, element) {
+	const elements = arr.getElements();
+	for (const el of elements) if (el.getText() === element) {
+		arr.removeElement(el);
+		return true;
+	}
+	return false;
+}
+function findDefaultExportObject(sourceFile) {
+	const defaultExport = sourceFile.getDefaultExportSymbol();
+	if (!defaultExport) return;
+	const declarations = defaultExport.getDeclarations();
+	for (const decl of declarations) if (Node.isExportAssignment(decl)) {
+		const expression = decl.getExpression();
+		if (expression.getKind() === SyntaxKind.ObjectLiteralExpression) return expression;
+	}
+}
+function findCallExpression(sourceFile, functionName) {
+	const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+	for (const call of callExpressions) if (call.getExpression().getText() === functionName) {
+		const args = call.getArguments();
+		if (args.length > 0 && args[0].getKind() === SyntaxKind.ObjectLiteralExpression) return args[0];
+	}
+}
+
+//#endregion
+export { addArrayElement, addExport, addImport, addImportedPresentation, addJournalEntry, addMigration, backupExists, clearJournal, createBackup, createEmptyManifest, createInitialState, createJournalEntry, createTransformer, deleteBackup, deleteJsonValue, deleteYamlValue, dryRun, findArrayLiteral, findCallExpression, findDefaultExportObject, findObjectLiteral, findWorkspaceRoot, formatDryRunOutput, formatRunOutput, formatStatus, getBackupMetadata, getFailedMigrations, getImportedPresentations, getJournalEntries, getJsonValue, getLastSuccessfulEntry, getMigrationById, getMigrationHistory, getMigrationOrder, getObjectProperty, getStatus, getYamlValue, hasMigration, initializeState, listBackups, loadInteractiveMigration, loadMigrations, mergeJson, mergeYaml, readJournal, readJsonFile, readManifest, readState, readYamlDocument, readYamlFile, removeArrayElement, removeImport, removeImportedPresentation, removeObjectProperty, restoreBackup, run, run$1 as runCli, setJsonValue, setObjectProperty, setYamlValue, stateExists, status, transformJson, transformTypeScript, transformYaml, transformYamlDocument, updateCliVersion, validateManifest, wasMigrationSuccessful, writeJournal, writeJsonFile, writeManifest, writeState, writeYamlDocument, writeYamlFile };