uniweb 0.7.1 → 0.7.2

package/src/index.js

@@ -8,30 +8,26 @@
  * Usage:
  *   npx uniweb create [project-name]
  *   npx uniweb create --template marketing
+ *   npx uniweb add foundation [name]
  *   npx uniweb build
  *   npx uniweb docs                          # Generate COMPONENTS.md from schema
  */
 
-import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from 'node:fs'
+import { existsSync } from 'node:fs'
 import { execSync } from 'node:child_process'
-import { resolve, join, dirname } from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { resolve, join, relative } from 'node:path'
 import prompts from 'prompts'
 import { build } from './commands/build.js'
 import { docs } from './commands/docs.js'
 import { doctor } from './commands/doctor.js'
 import { i18n } from './commands/i18n.js'
-import { getVersionsForTemplates, getVersion } from './versions.js'
+import { add } from './commands/add.js'
 import {
   resolveTemplate,
-  applyExternalTemplate,
   parseTemplateId,
-  listAvailableTemplates,
-  BUILTIN_TEMPLATES,
 } from './templates/index.js'
-import { copyTemplateDirectory, registerVersions } from './templates/processor.js'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
+import { validateTemplate } from './templates/validator.js'
+import { scaffoldWorkspace, scaffoldFoundation, scaffoldSite, applyContent, applyStarter } from './utils/scaffold.js'
 
 // Colors for terminal output
 const colors = {
@@ -60,79 +56,213 @@ function title(message) {
   console.log(`\n${colors.cyan}${colors.bright}${message}${colors.reset}\n`)
 }
 
-// Built-in template definitions (metadata for display)
-const templates = {
-  single: {
-    name: 'Single Project',
-    description: 'One site + one foundation in site/ and foundation/ (recommended)',
-  },
-  multi: {
-    name: 'Multi-Site Workspace',
-    description: 'Multiple sites and foundations in sites/* and foundations/*',
-  },
-}
-
 /**
- * Get the path to a built-in template
+ * Create a project using the new package template flow (default)
  */
-function getBuiltinTemplatePath(templateName) {
-  return join(__dirname, '..', 'templates', templateName)
+async function createFromPackageTemplates(projectDir, projectName, options = {}) {
+  const { onProgress, onWarning } = options
+
+  onProgress?.('Setting up workspace...')
+
+  // 1. Scaffold workspace
+  await scaffoldWorkspace(projectDir, {
+    projectName,
+    workspaceGlobs: ['foundation', 'site'],
+    scripts: {
+      dev: 'pnpm --filter site dev',
+      build: 'uniweb build',
+      preview: 'pnpm --filter site preview',
+    },
+  }, { onProgress, onWarning })
+
+  // 2. Scaffold foundation
+  onProgress?.('Creating foundation...')
+  await scaffoldFoundation(join(projectDir, 'foundation'), {
+    name: 'foundation',
+    projectName,
+    isExtension: false,
+  }, { onProgress, onWarning })
+
+  // 3. Scaffold site
+  onProgress?.('Creating site...')
+  await scaffoldSite(join(projectDir, 'site'), {
+    name: 'site',
+    projectName,
+    foundationName: 'foundation',
+    foundationPath: 'file:../foundation',
+  }, { onProgress, onWarning })
+
+  // 4. Apply starter content
+  onProgress?.('Adding starter content...')
+  await applyStarter(projectDir, { projectName }, { onProgress, onWarning })
+
+  success(`Created project: ${projectName}`)
 }
 
 /**
- * Get the shared base template path
+ * Create a blank workspace (no packages, grow with `add`)
  */
-function getSharedTemplatePath() {
-  return join(__dirname, '..', 'templates', '_shared')
+async function createBlankWorkspace(projectDir, projectName, options = {}) {
+  const { onProgress, onWarning } = options
+
+  onProgress?.('Setting up blank workspace...')
+
+  await scaffoldWorkspace(projectDir, {
+    projectName,
+    workspaceGlobs: [],
+    scripts: {
+      build: 'uniweb build',
+    },
+  }, { onProgress, onWarning })
+
+  success(`Created blank workspace: ${projectName}`)
 }
 
 /**
- * Apply a built-in template using file-based templates
+ * Create a project from a format 2 content template
+ *
+ * Scaffolds workspace structure from package templates, then overlays
+ * content (sections, pages, theme) from the content template.
  */
-async function applyBuiltinTemplate(templateName, targetPath, options = {}) {
-  const { projectName, variant, onProgress, onWarning } = options
+async function createFromContentTemplate(projectDir, projectName, metadata, templateRootPath, options = {}) {
+  const { onProgress, onWarning } = options
+
+  // Determine packages to create
+  const packages = metadata.packages || [
+    { type: 'foundation', name: 'foundation' },
+    { type: 'site', name: 'site', foundation: 'foundation' },
+  ]
+
+  // Compute placement for each package
+  const placed = computePlacement(packages)
+
+  // Compute workspace globs and scripts from placement
+  const workspaceGlobs = placed.map(p => p.relativePath)
+  const sites = placed.filter(p => p.type === 'site')
+  const scripts = {
+    build: 'uniweb build',
+  }
+  if (sites.length === 1) {
+    scripts.dev = `pnpm --filter ${sites[0].name} dev`
+    scripts.preview = `pnpm --filter ${sites[0].name} preview`
+  } else {
+    for (const s of sites) {
+      scripts[`dev:${s.name}`] = `pnpm --filter ${s.name} dev`
+      scripts[`preview:${s.name}`] = `pnpm --filter ${s.name} preview`
+    }
+    // First site gets unqualified aliases
+    if (sites.length > 0) {
+      scripts.dev = `pnpm --filter ${sites[0].name} dev`
+      scripts.preview = `pnpm --filter ${sites[0].name} preview`
+    }
+  }
 
-  const templatePath = getBuiltinTemplatePath(templateName)
+  // 1. Scaffold workspace
+  onProgress?.('Setting up workspace...')
+  await scaffoldWorkspace(projectDir, {
+    projectName,
+    workspaceGlobs,
+    scripts,
+  }, { onProgress, onWarning })
+
+  // 2. Scaffold and apply content for each package
+  for (const pkg of placed) {
+    const fullPath = join(projectDir, pkg.relativePath)
+
+    if (pkg.type === 'foundation' || pkg.type === 'extension') {
+      onProgress?.(`Creating ${pkg.type}: ${pkg.name}...`)
+      await scaffoldFoundation(fullPath, {
+        name: pkg.name,
+        projectName,
+        isExtension: pkg.type === 'extension',
+      }, { onProgress, onWarning })
+    } else if (pkg.type === 'site') {
+      // Find the foundation this site wires to
+      const foundationName = pkg.foundation || 'foundation'
+      const foundationPkg = placed.find(p =>
+        (p.type === 'foundation') && (p.name === foundationName)
+      )
+      const foundationPath = foundationPkg
+        ? computeFoundationFilePath(pkg.relativePath, foundationPkg.relativePath)
+        : 'file:../foundation'
+
+      onProgress?.(`Creating site: ${pkg.name}...`)
+      await scaffoldSite(fullPath, {
+        name: pkg.name,
+        projectName,
+        foundationName,
+        foundationPath,
+        foundationRef: foundationName !== 'foundation' ? foundationName : undefined,
+      }, { onProgress, onWarning })
+    }
 
-  // Load template.json for metadata
-  let templateConfig = {}
-  const configPath = join(templatePath, 'template.json')
-  if (existsSync(configPath)) {
-    templateConfig = JSON.parse(readFileSync(configPath, 'utf8'))
+    // Apply content from the matching content directory
+    const contentDir = findContentDirFor(metadata.contentDirs, pkg)
+    if (contentDir) {
+      onProgress?.(`Applying ${metadata.name} content to ${pkg.name}...`)
+      await applyContent(contentDir.dir, fullPath, { projectName }, { onProgress, onWarning })
+    }
   }
 
-  // Determine base template path if specified
-  let basePath = null
-  if (templateConfig.base) {
-    basePath = join(__dirname, '..', 'templates', templateConfig.base)
-    if (!existsSync(basePath)) {
-      if (onWarning) {
-        onWarning(`Base template '${templateConfig.base}' not found at ${basePath}`)
-      }
-      basePath = null
+  success(`Created project: ${projectName}`)
+}
+
+/**
+ * Compute placement (relative paths) for packages
+ *
+ * Rules:
+ * - 1 foundation named "foundation" → foundation/
+ * - Multiple foundations → foundations/{name}/
+ * - Extensions → extensions/{name}/
+ * - 1 site named "site" → site/
+ * - Multiple sites → sites/{name}/
+ */
+function computePlacement(packages) {
+  const foundations = packages.filter(p => p.type === 'foundation')
+  const extensions = packages.filter(p => p.type === 'extension')
+  const sites = packages.filter(p => p.type === 'site')
+
+  const placed = []
+
+  for (const f of foundations) {
+    if (foundations.length === 1 && f.name === 'foundation') {
+      placed.push({ ...f, relativePath: 'foundation' })
+    } else {
+      placed.push({ ...f, relativePath: `foundations/${f.name}` })
     }
   }
 
-  // Register versions for Handlebars templates
-  registerVersions(getVersionsForTemplates())
+  for (const e of extensions) {
+    placed.push({ ...e, relativePath: `extensions/${e.name}` })
+  }
 
-  // Prepare template data
-  const templateData = {
-    projectName: projectName || 'my-project',
-    templateName: templateName,
-    templateTitle: projectName || 'My Project',
-    templateDescription: templateConfig.description || 'A Uniweb project',
+  for (const s of sites) {
+    if (sites.length === 1 && s.name === 'site') {
+      placed.push({ ...s, relativePath: 'site' })
+    } else {
+      placed.push({ ...s, relativePath: `sites/${s.name}` })
+    }
   }
 
-  // Copy template files
-  await copyTemplateDirectory(templatePath, targetPath, templateData, {
-    variant,
-    basePath,
-    onProgress,
-    onWarning,
-  })
+  return placed
+}
 
-  success(`Created project: ${projectName || 'my-project'}`)
+/**
+ * Find the content directory that matches a placed package
+ */
+function findContentDirFor(contentDirs, pkg) {
+  if (!contentDirs) return null
+  // Match by name first, then by type
+  return contentDirs.find(d => d.name === pkg.name) ||
+         contentDirs.find(d => d.type === pkg.type && d.name === pkg.type)
+}
+
+/**
+ * Compute relative file: path from site to foundation
+ */
+function computeFoundationFilePath(sitePath, foundationPath) {
+  const rel = relative(sitePath, foundationPath)
+  return `file:${rel}`
 }
 
 async function main() {
@@ -169,6 +299,12 @@ async function main() {
     return
   }
 
+  // Handle add command
+  if (command === 'add') {
+    await add(args.slice(1))
+    return
+  }
+
   // Handle create command
   if (command !== 'create') {
     error(`Unknown command: ${command}`)
@@ -180,7 +316,7 @@ async function main() {
 
   // Parse arguments
   let projectName = args[1]
-  let templateType = "single"; // or null for iteractive selection
+  let templateType = null  // null = use new package template flow
 
   // Check for --template flag
   const templateIndex = args.indexOf('--template')
@@ -195,13 +331,6 @@ async function main() {
     }
   }
 
-  // Check for --variant flag
-  let variant = null
-  const variantIndex = args.indexOf('--variant')
-  if (variantIndex !== -1 && args[variantIndex + 1]) {
-    variant = args[variantIndex + 1]
-  }
-
   // Check for --name flag (used for project display name)
   let displayName = null
   const nameIndex = args.indexOf('--name')
@@ -212,6 +341,11 @@ async function main() {
   // Check for --no-git flag
   const noGit = args.includes('--no-git')
 
+  // Skip positional name if it starts with -- (it's a flag, not a name)
+  if (projectName && projectName.startsWith('--')) {
+    projectName = null
+  }
+
   // Interactive prompts
   const response = await prompts([
     {
@@ -227,23 +361,6 @@ async function main() {
         return true
       },
     },
-    {
-      type: templateType ? null : 'select',
-      name: 'template',
-      message: 'What would you like to create?',
-      choices: [
-        {
-          title: templates.single.name,
-          description: templates.single.description,
-          value: 'single',
-        },
-        {
-          title: templates.multi.name,
-          description: templates.multi.description,
-          value: 'multi',
-        },
-      ],
-    },
   ], {
     onCancel: () => {
       log('\nScaffolding cancelled.')
@@ -252,13 +369,14 @@ async function main() {
   })
 
   projectName = projectName || response.projectName
-  templateType = templateType || response.template
 
-  if (!projectName || !templateType) {
-    error('Missing project name or template type')
+  if (!projectName) {
+    error('Missing project name')
     process.exit(1)
   }
 
+  const effectiveName = displayName || projectName
+
   // Create project directory
   const projectDir = resolve(process.cwd(), projectName)
 
@@ -267,46 +385,53 @@ async function main() {
     process.exit(1)
   }
 
-  // Resolve and create project based on template
-  const parsed = parseTemplateId(templateType)
-
-  if (parsed.type === 'builtin') {
-    const templateMeta = templates[templateType]
-    log(`\nCreating ${templateMeta ? templateMeta.name.toLowerCase() : templateType}...`)
+  // Template routing logic
+  const progressCb = (msg) => log(`  ${colors.dim}${msg}${colors.reset}`)
+  const warningCb = (msg) => log(`  ${colors.yellow}Warning: ${msg}${colors.reset}`)
 
-    // Apply file-based built-in template
-    await applyBuiltinTemplate(templateType, projectDir, {
-      projectName: displayName || projectName,
-      variant,
-      onProgress: (msg) => log(`  ${colors.dim}${msg}${colors.reset}`),
-      onWarning: (msg) => log(`  ${colors.yellow}Warning: ${msg}${colors.reset}`),
+  if (templateType === 'blank') {
+    // Blank workspace
+    log('\nCreating blank workspace...')
+    await createBlankWorkspace(projectDir, effectiveName, {
+      onProgress: progressCb,
+      onWarning: warningCb,
+    })
+  } else if (!templateType) {
+    // Default flow (package templates + starter)
+    log('\nCreating project...')
+    await createFromPackageTemplates(projectDir, effectiveName, {
+      onProgress: progressCb,
+      onWarning: warningCb,
     })
   } else {
-    // External template (official, npm, or github)
+    // External: official/npm/github/local
     log(`\nResolving template: ${templateType}...`)
 
     try {
       const resolved = await resolveTemplate(templateType, {
-        onProgress: (msg) => log(`  ${colors.dim}${msg}${colors.reset}`),
+        onProgress: progressCb,
       })
 
       log(`\nCreating project from ${resolved.name || resolved.package || `${resolved.owner}/${resolved.repo}`}...`)
 
-      await applyExternalTemplate(resolved, projectDir, {
-        projectName: displayName || projectName,
-        versions: getVersionsForTemplates(),
-      }, {
-        variant,
-        onProgress: (msg) => log(`  ${colors.dim}${msg}${colors.reset}`),
-        onWarning: (msg) => log(`  ${colors.yellow}Warning: ${msg}${colors.reset}`),
-      })
+      // Validate and apply as format 2 content template
+      const metadata = await validateTemplate(resolved.path, {})
+
+      try {
+        await createFromContentTemplate(projectDir, effectiveName, metadata, resolved.path, {
+          onProgress: progressCb,
+          onWarning: warningCb,
+        })
+      } finally {
+        if (resolved.cleanup) await resolved.cleanup()
+      }
     } catch (err) {
       error(`Failed to apply template: ${err.message}`)
       log('')
       log(`${colors.yellow}Troubleshooting:${colors.reset}`)
       log(`  • Check your network connection`)
       log(`  • Official templates require GitHub access (may be blocked by corporate networks)`)
-      log(`  • Try the built-in template instead: ${colors.cyan}uniweb create ${projectName}${colors.reset}`)
+      log(`  • Try the default template instead: ${colors.cyan}uniweb create ${projectName}${colors.reset}`)
       process.exit(1)
     }
   }
@@ -332,10 +457,19 @@ async function main() {
   // Success message
   title('Project created successfully!')
 
-  log(`Next steps:\n`)
-  log(`  ${colors.cyan}cd ${projectName}${colors.reset}`)
-  log(`  ${colors.cyan}pnpm install${colors.reset}`)
-  log(`  ${colors.cyan}pnpm dev${colors.reset}`)
+  if (templateType === 'blank') {
+    log(`Next steps:\n`)
+    log(`  ${colors.cyan}cd ${projectName}${colors.reset}`)
+    log(`  ${colors.cyan}uniweb add foundation${colors.reset}`)
+    log(`  ${colors.cyan}uniweb add site${colors.reset}`)
+    log(`  ${colors.cyan}pnpm install${colors.reset}`)
+    log(`  ${colors.cyan}pnpm dev${colors.reset}`)
+  } else {
+    log(`Next steps:\n`)
+    log(`  ${colors.cyan}cd ${projectName}${colors.reset}`)
+    log(`  ${colors.cyan}pnpm install${colors.reset}`)
+    log(`  ${colors.cyan}pnpm dev${colors.reset}`)
+  }
   log('')
 }
 
@@ -348,16 +482,21 @@ ${colors.bright}Usage:${colors.reset}
 
 ${colors.bright}Commands:${colors.reset}
   create [name]      Create a new project
+  add <type> [name]  Add a foundation, site, or extension to a project
   build              Build the current project
   docs               Generate component documentation
   doctor             Diagnose project configuration issues
   i18n <cmd>         Internationalization (extract, sync, status)
 
 ${colors.bright}Create Options:${colors.reset}
-  --template <type>  Project template
-  --variant <name>   Template variant (e.g., tailwind3 for legacy)
+  --template <type>  Project template (default: creates foundation + site + starter)
   --name <name>      Project display name
-  --no-git             Skip git repository initialization
+  --no-git           Skip git repository initialization
+
+${colors.bright}Add Subcommands:${colors.reset}
+  add foundation [name]   Add a foundation (--from, --path, --project)
+  add site [name]         Add a site (--from, --foundation, --path, --project)
+  add extension <name>    Add an extension (--from, --site, --path)
 
 ${colors.bright}Build Options:${colors.reset}
   --target <type>    Build target (foundation, site) - auto-detected if not specified
@@ -386,8 +525,7 @@ ${colors.bright}i18n Commands:${colors.reset}
   status             Show translation coverage per locale
 
 ${colors.bright}Template Types:${colors.reset}
-  single                        One site + one foundation (default)
-  multi                         Multiple sites and foundations
+  blank                         Empty workspace (grow with 'add')
   marketing                     Official marketing template
   ./path/to/template            Local directory
   @scope/template-name          npm package
@@ -395,17 +533,21 @@ ${colors.bright}Template Types:${colors.reset}
   https://github.com/user/repo  GitHub URL
 
 ${colors.bright}Examples:${colors.reset}
-  npx uniweb create my-project
-  npx uniweb create my-project --template single
-  npx uniweb create my-project --template marketing
-  npx uniweb create my-project --template marketing --variant tailwind3
-  npx uniweb create my-project --template ./my-template
-  npx uniweb create my-project --template github:myorg/template
+  npx uniweb create my-project                           # Default (foundation + site + starter)
+  npx uniweb create my-project --template blank          # Blank workspace
+  npx uniweb create my-project --template marketing      # Official template
+  npx uniweb create my-project --template ./my-template  # Local template
+
+  cd my-project
+  npx uniweb add foundation marketing                    # Add foundations/marketing/
+  npx uniweb add foundation marketing --from marketing   # Scaffold + marketing sections
+  npx uniweb add site blog --foundation marketing        # Add sites/blog/ wired to marketing
+  npx uniweb add site blog --from docs --foundation blog # Scaffold + docs pages
+  npx uniweb add extension effects --site site           # Add extensions/effects/
+
   npx uniweb build
   npx uniweb build --target foundation
-  npx uniweb build                                     # Auto-prerenders if site.yml has build.prerender: true
-  npx uniweb build --no-prerender                      # Skip prerendering even if enabled in config
-  cd foundation && npx uniweb docs                     # Generate COMPONENTS.md
+  cd foundation && npx uniweb docs                       # Generate COMPONENTS.md
 `)
 }
 

package/src/templates/index.js

@@ -12,12 +12,6 @@ import { fetchNpmTemplate } from './fetchers/npm.js'
 import { fetchGitHubTemplate } from './fetchers/github.js'
 import { fetchOfficialTemplate, listOfficialTemplates } from './fetchers/release.js'
 import { validateTemplate } from './validator.js'
-import {
-  copyTemplateDirectory,
-  registerVersions,
-  getMissingVersions,
-  clearMissingVersions
-} from './processor.js'
 
 /**
  * Resolve a template identifier and return the template path
@@ -163,100 +157,12 @@ async function resolveLocalTemplate(templatePath, options = {}) {
   }
 }
 
-/**
- * Apply a template to a target directory
- *
- * @param {string} templatePath - Path to the template root (contains template.json)
- * @param {string} targetPath - Destination directory for the scaffolded project
- * @param {Object} data - Template variables
- * @param {Object} options - Apply options
- * @param {string} options.variant - Template variant to use
- * @param {string} options.uniwebVersion - Current Uniweb version for compatibility check
- * @param {Function} options.onWarning - Warning callback
- * @param {Function} options.onProgress - Progress callback
- * @returns {Promise<Object>} Template metadata
- */
-export async function applyTemplate(templatePath, targetPath, data = {}, options = {}) {
-  const { uniwebVersion, variant, onWarning, onProgress } = options
-
-  // Validate the template
-  const metadata = await validateTemplate(templatePath, { uniwebVersion })
-
-  // Register versions for the {{version}} helper
-  if (data.versions) {
-    registerVersions(data.versions)
-  }
-
-  // Apply default variables
-  const templateData = {
-    year: new Date().getFullYear(),
-    ...data
-  }
-
-  // Copy template files
-  await copyTemplateDirectory(
-    metadata.templateDir,
-    targetPath,
-    templateData,
-    { variant, onWarning, onProgress }
-  )
-
-  // Check for missing versions and warn
-  const missingVersions = getMissingVersions()
-  if (missingVersions.length > 0 && onWarning) {
-    onWarning(`Missing version data for packages: ${missingVersions.join(', ')}. Using fallback version.`)
-  }
-  clearMissingVersions()
-
-  return metadata
-}
-
-/**
- * Apply an external template to a target directory
- *
- * @param {Object} resolved - Resolved template from resolveTemplate()
- * @param {string} targetPath - Target directory
- * @param {Object} data - Template variables
- * @param {Object} options - Apply options
- */
-export async function applyExternalTemplate(resolved, targetPath, data, options = {}) {
-  const { variant, onProgress, onWarning } = options
-
-  try {
-    const metadata = await applyTemplate(
-      resolved.path,
-      targetPath,
-      data,
-      { variant, onProgress, onWarning }
-    )
-
-    return metadata
-  } finally {
-    // Clean up temp directory if there is one
-    if (resolved.cleanup) {
-      await resolved.cleanup()
-    }
-  }
-}
-
 /**
  * List all available templates
  */
 export async function listAvailableTemplates() {
   const templates = []
 
-  // Built-in templates
-  for (const name of BUILTIN_TEMPLATES) {
-    templates.push({
-      type: 'builtin',
-      id: name,
-      name: name.charAt(0).toUpperCase() + name.slice(1),
-      description: name === 'single'
-        ? 'One site + one foundation'
-        : 'Multiple sites and foundations',
-    })
-  }
-
   // Official templates from GitHub releases
   try {
     const official = await listOfficialTemplates()