bsmnt 0.0.2 → 0.1.0

package/packages/create-basement-app/src/configs/animations.js

@@ -0,0 +1,28 @@
+// packages/create-basement-app/src/configs/animations.js
+
+/**
+ * Animation library configuration manifest.
+ * Single source of truth for animation library dependencies.
+ */
+export const ANIMATION_CONFIG = {
+	gsap: {
+		dependencies: {
+			gsap: "^3.12.0",
+			"@gsap/react": "^2.0.0",
+		},
+	},
+	motion: {
+		dependencies: {
+			motion: "^12.0.0",
+		},
+	},
+};
+
+/**
+ * Get configuration for a specific animation library
+ * @param {string} name - The animation library name (e.g., 'gsap', 'motion')
+ * @returns {object|null} Animation configuration or null if not found
+ */
+export function getAnimationConfig(name) {
+	return ANIMATION_CONFIG[name] || null;
+}

package/packages/create-basement-app/src/index.js

@@ -0,0 +1,15 @@
+// packages/create-basement-app/src/index.js
+
+export { ANIMATION_CONFIG, getAnimationConfig } from "./configs/animations.js";
+export {
+	CMS_CONFIG,
+	getCmsConfig,
+	getLayerConfig,
+	isCmsSupported,
+	LAYER_CONFIG,
+} from "./mergers/config.js";
+export {
+	formatMergeResults,
+	injectIntegration,
+	injectLayer,
+} from "./mergers/index.js";

package/packages/create-basement-app/src/mergers/check-integration-merger.js

@@ -0,0 +1,105 @@
+// packages/create-basement-app/src/mergers/check-integration-merger.js
+import fs from "fs-extra";
+
+/**
+ * Sanity configuration check function to add
+ */
+const SANITY_FUNCTION = `
+/**
+ * Check if Sanity CMS is configured
+ * Requires: NEXT_PUBLIC_SANITY_PROJECT_ID and NEXT_PUBLIC_SANITY_DATASET
+ */
+export function isSanityConfigured(): boolean {
+  return Boolean(
+    process.env.NEXT_PUBLIC_SANITY_PROJECT_ID &&
+      process.env.NEXT_PUBLIC_SANITY_DATASET
+  )
+}
+`;
+
+/**
+ * Update to getConfiguredIntegrations to include Sanity
+ */
+const SANITY_CONFIGURED_CHECK = `  if (isSanityConfigured()) integrations.push("Sanity")`;
+
+/**
+ * Update to getUnconfiguredIntegrations to include Sanity
+ */
+const SANITY_UNCONFIGURED_CHECK = `  if (!isSanityConfigured()) integrations.push("Sanity")`;
+
+/**
+ * Merge Sanity integration into template check-integration
+ * @param {string} templatePath - Path to the template's check-integration.ts
+ * @returns {Promise<{skipped?: boolean, reason?: string, success?: boolean}>}
+ */
+export async function mergeCheckIntegration(templatePath) {
+	let content = await fs.readFile(templatePath, "utf-8");
+
+	// Skip if already has isSanityConfigured
+	if (content.includes("isSanityConfigured")) {
+		return { skipped: true, reason: "Already has isSanityConfigured" };
+	}
+
+	// 1. Add isSanityConfigured function after isAnalyticsConfigured
+	const analyticsMatch = content.match(
+		/(export function isAnalyticsConfigured\(\)[^}]+\})/s,
+	);
+	if (analyticsMatch) {
+		const insertPos = analyticsMatch.index + analyticsMatch[0].length;
+		content =
+			content.slice(0, insertPos) +
+			"\n" +
+			SANITY_FUNCTION +
+			content.slice(insertPos);
+	} else {
+		// If no isAnalyticsConfigured, add before getConfiguredIntegrations
+		const getConfiguredMatch = content.match(
+			/export function getConfiguredIntegrations/,
+		);
+		if (getConfiguredMatch) {
+			content =
+				content.slice(0, getConfiguredMatch.index) +
+				SANITY_FUNCTION +
+				"\n" +
+				content.slice(getConfiguredMatch.index);
+		} else {
+			// Fallback: append to end
+			content = `${content.trimEnd()}\n${SANITY_FUNCTION}`;
+		}
+	}
+
+	// 2. Update getConfiguredIntegrations to include Sanity check
+	const configuredFnMatch = content.match(
+		/(export function getConfiguredIntegrations\(\)[^{]*\{[\s\S]*?)(if \(isAnalyticsConfigured\(\)\))/m,
+	);
+	if (configuredFnMatch) {
+		const insertPos = content.indexOf(
+			configuredFnMatch[2],
+			configuredFnMatch.index,
+		);
+		content =
+			content.slice(0, insertPos) +
+			SANITY_CONFIGURED_CHECK +
+			"\n  " +
+			content.slice(insertPos);
+	}
+
+	// 3. Update getUnconfiguredIntegrations to include Sanity check
+	const unconfiguredFnMatch = content.match(
+		/(export function getUnconfiguredIntegrations\(\)[^{]*\{[\s\S]*?)(if \(!isAnalyticsConfigured\(\)\))/m,
+	);
+	if (unconfiguredFnMatch) {
+		const insertPos = content.indexOf(
+			unconfiguredFnMatch[2],
+			unconfiguredFnMatch.index,
+		);
+		content =
+			content.slice(0, insertPos) +
+			SANITY_UNCONFIGURED_CHECK +
+			"\n  " +
+			content.slice(insertPos);
+	}
+
+	await fs.writeFile(templatePath, content);
+	return { success: true };
+}

package/{src → packages/create-basement-app/src}/mergers/config.js

@@ -1,4 +1,4 @@
-// src/mergers/config.js
+// packages/create-basement-app/src/mergers/config.js
 
 /**
  * CMS-specific configuration for smart merge integration
@@ -6,9 +6,6 @@
  */
 export const CMS_CONFIG = {
 	sanity: {
-		// Git branch containing the Sanity integration files
-		branch: "sanity-integration",
-
 		// Files that need smart merging (exist in both template and integration)
 		mergeFiles: [
 			"app/layout.tsx",
@@ -31,9 +28,6 @@ export const CMS_CONFIG = {
 	},
 
 	basehub: {
-		// Git branch containing the BaseHub integration files
-		branch: "basehub-integration",
-
 		// Files that need smart merging for BaseHub
 		mergeFiles: [],
 

package/{src → packages/create-basement-app/src}/mergers/index.js

@@ -1,10 +1,8 @@
-// src/mergers/index.js
+// packages/create-basement-app/src/mergers/index.js
 
-import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import fs from "fs-extra";
-import tiged from "tiged";
 import { getCmsConfig, getLayerConfig } from "./config.js";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -17,13 +15,17 @@ const __dirname = path.dirname(__filename);
 const CMS_MERGERS = {
 	sanity: {
 		"app/layout.tsx": () =>
-			import("./layout-merger.js").then((m) => m.mergeLayout),
+			import("../../integrations/sanity/mergers/layout-merger.js").then(
+				(m) => m.mergeLayout,
+			),
 		"app/sitemap.ts": () =>
-			import("./sitemap-merger.js").then((m) => m.mergeSitemap),
-		"lib/integrations/check-integration.ts": () =>
-			import("./check-integration-merger.js").then(
-				(m) => m.mergeCheckIntegration,
+			import("../../integrations/sanity/mergers/sitemap-merger.js").then(
+				(m) => m.mergeSitemap,
 			),
+		"lib/integrations/check-integration.ts": () =>
+			import(
+				"../../integrations/sanity/mergers/check-integration-merger.js"
+			).then((m) => m.mergeCheckIntegration),
 	},
 	basehub: {
 		// BaseHub mergers would go here when implemented
@@ -113,7 +115,7 @@ export async function injectIntegration(targetDir, cms, spinner) {
 		return results;
 	}
 
-	const { branch, mergeFiles, additivePaths } = cmsConfig;
+	const { mergeFiles, additivePaths } = cmsConfig;
 
 	// Detect if project uses src/ prefix (e.g., src/app/ instead of app/)
 	const pathPrefix = await detectPathPrefix(targetDir);
@@ -121,111 +123,103 @@ export async function injectIntegration(targetDir, cms, spinner) {
 		spinner.text = `Detected src/ directory structure...`;
 	}
 
-	// 1. Clone integration to temp directory
-	const tempDir = path.join(os.tmpdir(), `integration-${Date.now()}`);
+	// Resolve local integration files directory
+	const integrationDir = path.resolve(
+		__dirname,
+		"../../integrations",
+		cms,
+		"files",
+	);
 
-	try {
-		spinner.text = `Downloading ${cms} integration...`;
-
-		// Use CMS-specific branch
-		const integrationRepoPath = `github:basementstudio/basement-cli/integrations/${cms}#${branch}`;
-		const emitter = tiged(integrationRepoPath, {
-			cache: false,
-			force: true,
-			mode: "git",
+	if (!(await fs.pathExists(integrationDir))) {
+		results.failed.push({
+			path: cms,
+			error: `Integration directory not found: ${integrationDir}`,
 		});
+		return results;
+	}
 
-		await emitter.clone(tempDir);
-
-		// 2. Copy additive files/directories (CMS-specific paths)
-		spinner.text = `Adding ${cms} files...`;
+	// 1. Copy additive files/directories (CMS-specific paths)
+	spinner.text = `Adding ${cms} files...`;
 
-		for (const additivePath of additivePaths) {
-			const src = path.join(tempDir, additivePath);
-			// Transform destination path based on project structure
-			const transformedPath = transformPath(additivePath, pathPrefix);
-			const dest = path.join(targetDir, transformedPath);
+	for (const additivePath of additivePaths) {
+		const src = path.join(integrationDir, additivePath);
+		// Transform destination path based on project structure
+		const transformedPath = transformPath(additivePath, pathPrefix);
+		const dest = path.join(targetDir, transformedPath);
 
-			try {
-				if (await fs.pathExists(src)) {
-					await fs.copy(src, dest, { overwrite: false });
-					results.copied.push(transformedPath);
-				}
-			} catch (error) {
-				results.failed.push({ path: transformedPath, error: error.message });
+		try {
+			if (await fs.pathExists(src)) {
+				await fs.copy(src, dest, { overwrite: false });
+				results.copied.push(transformedPath);
 			}
+		} catch (error) {
+			results.failed.push({ path: transformedPath, error: error.message });
 		}
+	}
 
-		// 3. Smart merge files that exist in both (CMS-specific mergers)
-		if (mergeFiles.length > 0) {
-			spinner.text = `Merging ${cms} integration...`;
-
-			for (const mergeFile of mergeFiles) {
-				// Transform path for the target project
-				const transformedPath = transformPath(mergeFile, pathPrefix);
-				const templateFile = path.join(targetDir, transformedPath);
-				const integrationFile = path.join(tempDir, mergeFile);
-
-				try {
-					// Check if template file exists
-					if (!(await fs.pathExists(templateFile))) {
-						// Template doesn't have this file - copy from integration
-						if (await fs.pathExists(integrationFile)) {
-							await fs.ensureDir(path.dirname(templateFile));
-							await fs.copy(integrationFile, templateFile);
-							results.copied.push(transformedPath);
-						} else {
-							results.skipped.push({
-								path: transformedPath,
-								reason: "Not in integration",
-							});
-						}
-						continue;
-					}
+	// 2. Smart merge files that exist in both (CMS-specific mergers)
+	if (mergeFiles.length > 0) {
+		spinner.text = `Merging ${cms} integration...`;
 
-					// Check if integration file exists
-					if (!(await fs.pathExists(integrationFile))) {
+		for (const mergeFile of mergeFiles) {
+			// Transform path for the target project
+			const transformedPath = transformPath(mergeFile, pathPrefix);
+			const templateFile = path.join(targetDir, transformedPath);
+			const integrationFile = path.join(integrationDir, mergeFile);
+
+			try {
+				// Check if template file exists
+				if (!(await fs.pathExists(templateFile))) {
+					// Template doesn't have this file - copy from integration
+					if (await fs.pathExists(integrationFile)) {
+						await fs.ensureDir(path.dirname(templateFile));
+						await fs.copy(integrationFile, templateFile);
+						results.copied.push(transformedPath);
+					} else {
 						results.skipped.push({
 							path: transformedPath,
 							reason: "Not in integration",
 						});
-						continue;
 					}
+					continue;
+				}
 
-					// Get the CMS-specific merger function (use base path for lookup)
-					const merger = await getMerger(cms, mergeFile);
+				// Check if integration file exists
+				if (!(await fs.pathExists(integrationFile))) {
+					results.skipped.push({
+						path: transformedPath,
+						reason: "Not in integration",
+					});
+					continue;
+				}
 
-					if (merger) {
-						const result = await merger(templateFile, {
-							targetDir,
-							pathPrefix,
-						});
-						if (result.skipped) {
-							results.skipped.push({
-								path: transformedPath,
-								reason: result.reason,
-							});
-						} else {
-							results.merged.push(transformedPath);
-						}
-					} else {
+				// Get the CMS-specific merger function (use base path for lookup)
+				const merger = await getMerger(cms, mergeFile);
+
+				if (merger) {
+					const result = await merger(templateFile, {
+						targetDir,
+						pathPrefix,
+					});
+					if (result.skipped) {
 						results.skipped.push({
 							path: transformedPath,
-							reason: `No merger for ${cms}`,
+							reason: result.reason,
 						});
+					} else {
+						results.merged.push(transformedPath);
 					}
-				} catch (error) {
-					results.failed.push({ path: transformedPath, error: error.message });
+				} else {
+					results.skipped.push({
+						path: transformedPath,
+						reason: `No merger for ${cms}`,
+					});
 				}
+			} catch (error) {
+				results.failed.push({ path: transformedPath, error: error.message });
 			}
 		}
-	} finally {
-		// 4. Cleanup temp directory
-		try {
-			await fs.remove(tempDir);
-		} catch {
-			// Ignore cleanup errors
-		}
 	}
 
 	return results;
@@ -253,8 +247,8 @@ export async function injectLayer(targetDir, layer, spinner) {
 		return results;
 	}
 
-	// Resolve the layer directory from the CLI repo's layers/{type}/ path
-	const layerDir = path.resolve(__dirname, "../../layers", layer);
+	// Resolve the layer directory from create-basement-app's templates/{type}/ path
+	const layerDir = path.resolve(__dirname, "../../templates", layer);
 
 	if (!(await fs.pathExists(layerDir))) {
 		results.skipped.push({

package/packages/create-basement-app/src/mergers/layout-merger.js

@@ -0,0 +1,223 @@
+// packages/create-basement-app/src/mergers/layout-merger.js
+
+import path from "node:path";
+import fs from "fs-extra";
+
+/**
+ * Sanity-specific imports to inject into layout.
+ * Only two lightweight components — no dynamic functions (draftMode, headers, etc.)
+ */
+const SANITY_IMPORTS = `import { SanityStudioGuard } from "@/components/sanity/studio-guard"
+import { SanityVisualEditing } from "@/components/sanity/visual-editing"`;
+
+/**
+ * Client component that hides site chrome on /studio routes.
+ * Uses useSelectedLayoutSegment() — a stable Next.js client API.
+ */
+const STUDIO_GUARD_COMPONENT = `"use client"
+
+import { useSelectedLayoutSegment } from "next/navigation"
+
+export function SanityStudioGuard({ children }: { children: React.ReactNode }) {
+  const segment = useSelectedLayoutSegment()
+  if (segment === "studio") return null
+  return <>{children}</>
+}
+`;
+
+/**
+ * Server component that handles Sanity visual editing.
+ * Keeps draftMode() inside its own <Suspense> boundary so the root layout
+ * never calls dynamic functions directly — preserving static rendering.
+ */
+const VISUAL_EDITING_COMPONENT = `import { Suspense } from "react"
+import { draftMode } from "next/headers"
+import { VisualEditing } from "next-sanity/visual-editing"
+import { isSanityConfigured } from "@/lib/integrations/check-integration"
+import { SanityLive } from "@/lib/integrations/sanity/live"
+
+async function VisualEditingInner() {
+  const { isEnabled: isDraftMode } = await draftMode()
+  const sanityConfigured = isSanityConfigured()
+
+  if (!sanityConfigured || !isDraftMode) return null
+
+  return (
+    <>
+      <VisualEditing />
+      <SanityLive />
+    </>
+  )
+}
+
+export function SanityVisualEditing() {
+  return (
+    <Suspense fallback={null}>
+      <VisualEditingInner />
+    </Suspense>
+  )
+}
+`;
+
+/**
+ * Merge Sanity integration into template layout.
+ * The layout itself stays free of dynamic functions (draftMode, headers, etc.)
+ * All dynamic behavior is encapsulated in generated components.
+ *
+ * Strategy:
+ * 1. Inject two imports (SanityStudioGuard, SanityVisualEditing)
+ * 2. Wrap body chrome in <SanityStudioGuard>
+ * 3. Add <SanityVisualEditing /> before </body>
+ * 4. Generate the two component files
+ *
+ * @param {string} templatePath - Path to the template's layout.tsx
+ * @param {object} options - Options from the merge orchestrator
+ * @param {string} options.targetDir - The project root directory
+ * @param {string} options.pathPrefix - Path prefix (e.g., 'src/' or '')
+ * @returns {Promise<{skipped?: boolean, reason?: string, success?: boolean}>}
+ */
+export async function mergeLayout(
+	templatePath,
+	{ targetDir, pathPrefix } = {},
+) {
+	let content = await fs.readFile(templatePath, "utf-8");
+
+	// Skip if already has Sanity integration
+	if (
+		content.includes("SanityStudioGuard") ||
+		content.includes("isSanityConfigured")
+	) {
+		return { skipped: true, reason: "Already has Sanity integration" };
+	}
+
+	// 1. Add Sanity imports after existing imports
+	const importMatches = [...content.matchAll(/^import .+$/gm)];
+	if (importMatches.length > 0) {
+		const lastImport = importMatches[importMatches.length - 1];
+		const insertPos = lastImport.index + lastImport[0].length;
+		content =
+			content.slice(0, insertPos) +
+			"\n" +
+			SANITY_IMPORTS +
+			content.slice(insertPos);
+	}
+
+	// 2. Ensure Suspense is imported from react
+	if (!content.match(/import\s+.*Suspense.*from\s+["']react["']/)) {
+		const reactImportMatch = content.match(
+			/import\s+\{([^}]*)\}\s+from\s+["']react["']/,
+		);
+		if (reactImportMatch) {
+			if (!reactImportMatch[1].includes("Suspense")) {
+				content = content.replace(
+					reactImportMatch[0],
+					reactImportMatch[0].replace(
+						reactImportMatch[1],
+						`${reactImportMatch[1].trim()}, Suspense`,
+					),
+				);
+			}
+		} else {
+			const lastImportMatch = content.match(/^(import\s+.+\n)/gm);
+			if (lastImportMatch) {
+				const lastImport = lastImportMatch[lastImportMatch.length - 1];
+				content = content.replace(
+					lastImport,
+					`${lastImport}import { Suspense } from "react"\n`,
+				);
+			}
+		}
+	}
+
+	// 3. Wrap body chrome in <SanityStudioGuard> and add <SanityVisualEditing />
+	content = content.replace(
+		/(\s*)(<body[^>]*>)([\s\S]*?)(\{children\})([\s\S]*?)(<\/body>)/m,
+		(
+			_match,
+			bodyIndent,
+			bodyOpen,
+			beforeChildren,
+			_childrenExpr,
+			afterChildren,
+			bodyClose,
+		) => {
+			const baseIndent = bodyIndent || "        ";
+			const indent = `${baseIndent}  `;
+			const innerIndent = `${indent}  `;
+
+			const trimmedBefore = beforeChildren.trim();
+			const trimmedAfter = afterChildren.trim();
+			const hasChrome = trimmedBefore.length > 0 || trimmedAfter.length > 0;
+
+			// Preserve relative indentation of chrome content
+			const reindent = (text, targetIndent) => {
+				const lines = text.split("\n").filter((line) => line.trim());
+				if (lines.length === 0) return "";
+				const minIndent = Math.min(
+					...lines
+						.map((line) => line.match(/^(\s*)/)[1].length)
+						.filter((n) => n > 0),
+					Infinity,
+				);
+				return lines
+					.map((line) => {
+						const currentIndent = line.match(/^(\s*)/)[1].length;
+						const relativeIndent = Math.max(
+							0,
+							currentIndent - (minIndent === Infinity ? 0 : minIndent),
+						);
+						return targetIndent + " ".repeat(relativeIndent) + line.trim();
+					})
+					.join("\n");
+			};
+
+			let result = `${baseIndent}${bodyOpen}\n`;
+
+			if (hasChrome && trimmedBefore) {
+				result += `${indent}<Suspense fallback={null}>\n`;
+				result += `${innerIndent}<SanityStudioGuard>\n`;
+				result += reindent(trimmedBefore, `${innerIndent}  `);
+				result += `\n${innerIndent}</SanityStudioGuard>\n`;
+				result += `${indent}</Suspense>\n\n`;
+			}
+
+			result += `${indent}{children}\n`;
+
+			if (hasChrome && trimmedAfter) {
+				result += `\n${indent}<Suspense fallback={null}>\n`;
+				result += `${innerIndent}<SanityStudioGuard>\n`;
+				result += reindent(trimmedAfter, `${innerIndent}  `);
+				result += `\n${innerIndent}</SanityStudioGuard>\n`;
+				result += `${indent}</Suspense>\n`;
+			}
+
+			result += `\n${indent}<SanityVisualEditing />\n${baseIndent}${bodyClose}`;
+			return result;
+		},
+	);
+
+	await fs.writeFile(templatePath, content);
+
+	// 3. Generate component files
+	if (targetDir) {
+		const sanityDir = path.join(
+			targetDir,
+			pathPrefix || "",
+			"components",
+			"sanity",
+		);
+		await fs.ensureDir(sanityDir);
+
+		const guardPath = path.join(sanityDir, "studio-guard.tsx");
+		if (!(await fs.pathExists(guardPath))) {
+			await fs.writeFile(guardPath, STUDIO_GUARD_COMPONENT);
+		}
+
+		const visualEditingPath = path.join(sanityDir, "visual-editing.tsx");
+		if (!(await fs.pathExists(visualEditingPath))) {
+			await fs.writeFile(visualEditingPath, VISUAL_EDITING_COMPONENT);
+		}
+	}
+
+	return { success: true };
+}