kofi-stack-template-generator 2.0.0

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "kofi-stack-template-generator",
+  "version": "2.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "pnpm run prebuild && tsup src/index.ts --format esm --dts",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "prebuild": "node scripts/generate-templates.js",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "kofi-stack-types": "^2.0.0",
+    "handlebars": "^4.7.8",
+    "memfs": "^4.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/scripts/generate-templates.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+/**
+ * Generate templates.generated.ts from template files
+ *
+ * This script reads all template files from the templates/ directory
+ * and embeds them as a TypeScript object for browser/Node.js compatibility.
+ */
+
+import { readdirSync, readFileSync, writeFileSync, statSync, existsSync } from 'fs'
+import { join, relative, extname } from 'path'
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const TEMPLATES_DIR = join(__dirname, '..', 'templates')
+const OUTPUT_FILE = join(__dirname, '..', 'src', 'templates.generated.ts')
+
+// Binary extensions that should be base64 encoded
+const BINARY_EXTENSIONS = new Set([
+  '.png', '.jpg', '.jpeg', '.gif', '.ico', '.webp', '.svg',
+  '.woff', '.woff2', '.ttf', '.eot', '.otf',
+  '.mp3', '.mp4', '.webm', '.pdf', '.zip', '.tar', '.gz'
+])
+
+function isBinaryFile(filename) {
+  const ext = extname(filename).toLowerCase()
+  return BINARY_EXTENSIONS.has(ext)
+}
+
+function getAllFiles(dir, baseDir = dir) {
+  const files = []
+
+  if (!existsSync(dir)) {
+    console.warn(`Warning: Templates directory not found at ${dir}`)
+    return files
+  }
+
+  const entries = readdirSync(dir)
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry)
+    const stat = statSync(fullPath)
+
+    if (stat.isDirectory()) {
+      files.push(...getAllFiles(fullPath, baseDir))
+    } else {
+      const relativePath = relative(baseDir, fullPath)
+      files.push({
+        path: relativePath.replace(/\\/g, '/'), // Normalize to forward slashes
+        fullPath
+      })
+    }
+  }
+
+  return files
+}
+
+function generateTemplates() {
+  console.log('Generating templates.generated.ts...')
+
+  const files = getAllFiles(TEMPLATES_DIR)
+
+  if (files.length === 0) {
+    // Create empty templates file if no templates exist yet
+    const output = `// Auto-generated file. Do not edit manually.
+// Run 'pnpm prebuild' to regenerate.
+
+export const EMBEDDED_TEMPLATES: Record<string, string> = {}
+`
+    writeFileSync(OUTPUT_FILE, output)
+    console.log('Created empty templates.generated.ts (no templates found)')
+    return
+  }
+
+  const templates = {}
+
+  for (const file of files) {
+    const content = readFileSync(file.fullPath)
+
+    if (isBinaryFile(file.path)) {
+      // Base64 encode binary files
+      templates[file.path] = content.toString('base64')
+    } else {
+      // Store text files as-is
+      templates[file.path] = content.toString('utf-8')
+    }
+  }
+
+  // Generate the TypeScript file
+  const output = `// Auto-generated file. Do not edit manually.
+// Run 'pnpm prebuild' to regenerate.
+// Generated: ${new Date().toISOString()}
+// Template count: ${files.length}
+
+export const EMBEDDED_TEMPLATES: Record<string, string> = ${JSON.stringify(templates, null, 2)}
+`
+
+  writeFileSync(OUTPUT_FILE, output)
+  console.log(`Generated templates.generated.ts with ${files.length} templates`)
+}
+
+generateTemplates()

package/src/core/index.ts

@@ -0,0 +1,7 @@
+export { VirtualFileSystem } from './virtual-fs.js'
+export {
+  processTemplateString,
+  transformFilename,
+  isBinaryFile,
+  shouldIncludeFile,
+} from './template-processor.js'

package/src/core/template-processor.ts

@@ -0,0 +1,127 @@
+import Handlebars from 'handlebars'
+import type { ProjectConfig } from 'kofi-stack-types'
+import path from 'path'
+
+// Register custom Handlebars helpers
+Handlebars.registerHelper('eq', (a: unknown, b: unknown) => a === b)
+Handlebars.registerHelper('ne', (a: unknown, b: unknown) => a !== b)
+Handlebars.registerHelper('and', (...args: unknown[]) => {
+  // Remove the options object (last argument)
+  const values = args.slice(0, -1)
+  return values.every(Boolean)
+})
+Handlebars.registerHelper('or', (...args: unknown[]) => {
+  const values = args.slice(0, -1)
+  return values.some(Boolean)
+})
+Handlebars.registerHelper('includes', (array: unknown[], value: unknown) => {
+  if (!Array.isArray(array)) return false
+  return array.includes(value)
+})
+Handlebars.registerHelper('not', (value: unknown) => !value)
+Handlebars.registerHelper('json', (value: unknown) => JSON.stringify(value, null, 2))
+
+// Binary file extensions that shouldn't be processed as templates
+const BINARY_EXTENSIONS = new Set([
+  '.png',
+  '.jpg',
+  '.jpeg',
+  '.gif',
+  '.ico',
+  '.webp',
+  '.svg',
+  '.woff',
+  '.woff2',
+  '.ttf',
+  '.eot',
+  '.otf',
+  '.mp3',
+  '.mp4',
+  '.webm',
+  '.pdf',
+  '.zip',
+  '.tar',
+  '.gz',
+])
+
+/**
+ * Check if a file is binary based on extension
+ */
+export function isBinaryFile(filename: string): boolean {
+  const ext = path.extname(filename).toLowerCase()
+  return BINARY_EXTENSIONS.has(ext)
+}
+
+/**
+ * Process a Handlebars template string with the given config context
+ */
+export function processTemplateString(
+  template: string,
+  config: ProjectConfig
+): string {
+  try {
+    const compiled = Handlebars.compile(template, { noEscape: true })
+    return compiled(config)
+  } catch (error) {
+    console.error('Template processing error:', error)
+    return template
+  }
+}
+
+/**
+ * Transform a template filename to the final output filename
+ * - Remove .hbs extension
+ * - Convert _gitignore to .gitignore
+ * - Process filename through Handlebars if it contains {{ }}
+ */
+export function transformFilename(
+  filename: string,
+  config: ProjectConfig
+): string {
+  let result = filename
+
+  // Remove .hbs extension
+  if (result.endsWith('.hbs')) {
+    result = result.slice(0, -4)
+  }
+
+  // Convert underscore prefix to dot prefix (for hidden files)
+  if (result.startsWith('_')) {
+    result = '.' + result.slice(1)
+  }
+
+  // Process filename through Handlebars if it contains template syntax
+  if (result.includes('{{')) {
+    result = processTemplateString(result, config)
+  }
+
+  return result
+}
+
+/**
+ * Check if a template file should be processed
+ * Some files are conditionally included based on config
+ */
+export function shouldIncludeFile(
+  templatePath: string,
+  config: ProjectConfig
+): boolean {
+  // Files in conditional directories
+  if (templatePath.includes('/if-monorepo/') && config.structure !== 'monorepo') {
+    return false
+  }
+  if (templatePath.includes('/if-standalone/') && config.structure !== 'standalone') {
+    return false
+  }
+  if (templatePath.includes('/if-payload/') && config.marketingSite !== 'payload') {
+    return false
+  }
+  if (templatePath.includes('/if-posthog/') && config.integrations.analytics !== 'posthog') {
+    return false
+  }
+  if (templatePath.includes('/if-uploadthing/') && config.integrations.uploads !== 'uploadthing') {
+    return false
+  }
+
+  return true
+}

package/src/core/virtual-fs.ts

@@ -0,0 +1,189 @@
+import { createFsFromVolume, Volume } from 'memfs'
+import type {
+  VirtualFile,
+  VirtualDirectory,
+  VirtualNode,
+  VirtualFileTree,
+  ProjectConfig,
+} from 'kofi-stack-types'
+import path from 'path'
+
+/**
+ * Virtual filesystem using memfs for in-memory file operations.
+ * This allows us to generate the entire project tree without disk I/O,
+ * enabling browser compatibility and faster generation.
+ */
+export class VirtualFileSystem {
+  private volume: InstanceType<typeof Volume>
+  private fs: ReturnType<typeof createFsFromVolume>
+  private binarySourcePaths: Map<string, string> = new Map()
+
+  constructor() {
+    this.volume = new Volume()
+    this.fs = createFsFromVolume(this.volume)
+  }
+
+  /**
+   * Write a file to the virtual filesystem
+   */
+  writeFile(filePath: string, content: string | Buffer): void {
+    const dir = path.dirname(filePath)
+    this.mkdir(dir)
+    this.fs.writeFileSync(filePath, content)
+  }
+
+  /**
+   * Read a file from the virtual filesystem
+   */
+  readFile(filePath: string): string | Buffer {
+    return this.fs.readFileSync(filePath)
+  }
+
+  /**
+   * Check if a path exists
+   */
+  exists(filePath: string): boolean {
+    try {
+      this.fs.statSync(filePath)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Check if path is a file
+   */
+  fileExists(filePath: string): boolean {
+    try {
+      return this.fs.statSync(filePath).isFile()
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Check if path is a directory
+   */
+  directoryExists(filePath: string): boolean {
+    try {
+      return this.fs.statSync(filePath).isDirectory()
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Create directory recursively
+   */
+  mkdir(dirPath: string): void {
+    if (!this.exists(dirPath)) {
+      this.fs.mkdirSync(dirPath, { recursive: true })
+    }
+  }
+
+  /**
+   * Delete a file
+   */
+  deleteFile(filePath: string): void {
+    if (this.fileExists(filePath)) {
+      this.fs.unlinkSync(filePath)
+    }
+  }
+
+  /**
+   * List directory contents
+   */
+  listDir(dirPath: string): string[] {
+    if (!this.directoryExists(dirPath)) {
+      return []
+    }
+    return this.fs.readdirSync(dirPath) as string[]
+  }
+
+  /**
+   * Track source path for binary files (for later copying)
+   */
+  setBinarySourcePath(virtualPath: string, sourcePath: string): void {
+    this.binarySourcePaths.set(virtualPath, sourcePath)
+  }
+
+  /**
+   * Get source path for binary file
+   */
+  getBinarySourcePath(virtualPath: string): string | undefined {
+    return this.binarySourcePaths.get(virtualPath)
+  }
+
+  /**
+   * Convert the virtual filesystem to a tree structure
+   */
+  toTree(config: ProjectConfig): VirtualFileTree {
+    const root = this.buildTree('/')
+    const stats = this.countNodes(root)
+
+    return {
+      root,
+      fileCount: stats.files,
+      directoryCount: stats.directories,
+      config,
+    }
+  }
+
+  private buildTree(dirPath: string): VirtualDirectory {
+    const name = dirPath === '/' ? '/' : path.basename(dirPath)
+    const children: VirtualNode[] = []
+
+    const entries = this.listDir(dirPath)
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry)
+      const stat = this.fs.statSync(fullPath)
+
+      if (stat.isDirectory()) {
+        children.push(this.buildTree(fullPath))
+      } else {
+        const content = this.fs.readFileSync(fullPath)
+        const file: VirtualFile = {
+          type: 'file',
+          path: fullPath,
+          name: entry,
+          content: content as string | Buffer,
+          extension: path.extname(entry),
+          sourcePath: this.binarySourcePaths.get(fullPath),
+        }
+        children.push(file)
+      }
+    }
+
+    return {
+      type: 'directory',
+      path: dirPath,
+      name,
+      children,
+    }
+  }
+
+  private countNodes(node: VirtualNode): { files: number; directories: number } {
+    if (node.type === 'file') {
+      return { files: 1, directories: 0 }
+    }
+
+    let files = 0
+    let directories = 1 // Count this directory
+
+    for (const child of node.children) {
+      const counts = this.countNodes(child)
+      files += counts.files
+      directories += counts.directories
+    }
+
+    return { files, directories }
+  }
+
+  /**
+   * Get the raw memfs instance for advanced operations
+   */
+  getRawFs(): ReturnType<typeof createFsFromVolume> {
+    return this.fs
+  }
+}