uniweb 0.2.42 → 0.2.43

package/src/commands/docs.js

@@ -7,15 +7,24 @@
  *   uniweb docs                    # Generate docs for current directory
  *   uniweb docs --output README.md # Custom output filename
  *   uniweb docs --from-source      # Build schema from source (no build required)
+ *   uniweb docs --target <path>    # Specify foundation directory explicitly
  *
  * When run from a site directory, automatically finds and documents the
  * linked foundation, placing COMPONENTS.md in the site folder.
+ *
+ * When run from workspace root, auto-detects foundations. If multiple exist,
+ * prompts for selection.
  */
 
 import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import { resolve, join, dirname } from 'node:path'
 import { generateDocs } from '@uniweb/build'
+import {
+  isWorkspaceRoot,
+  findFoundations,
+  promptSelect,
+} from '../utils/workspace.js'
 
 // Colors for terminal output
 const colors = {
@@ -51,6 +60,7 @@ function parseArgs(args) {
   const options = {
     output: 'COMPONENTS.md',
     fromSource: false,
+    target: null,
   }
 
   for (let i = 0; i < args.length; i++) {
@@ -60,6 +70,8 @@ function parseArgs(args) {
       options.output = args[++i]
     } else if (arg === '--from-source' || arg === '-s') {
       options.fromSource = true
+    } else if (arg === '--target' || arg === '-t') {
+      options.target = args[++i]
     } else if (arg === '--help' || arg === '-h') {
       options.help = true
     }
@@ -79,16 +91,19 @@ ${colors.dim}Usage:${colors.reset}
   uniweb docs                         Generate COMPONENTS.md
   uniweb docs --output DOCS.md        Custom output filename
   uniweb docs --from-source           Build schema from source (no build required)
+  uniweb docs --target foundation     Specify foundation directory explicitly
 
 ${colors.dim}Options:${colors.reset}
   -o, --output <file>    Output filename (default: COMPONENTS.md)
   -s, --from-source      Read meta.js files directly instead of schema.json
+  -t, --target <path>    Foundation directory (auto-detected if not specified)
   -h, --help             Show this help message
 
 ${colors.dim}Notes:${colors.reset}
   Run from a foundation directory to generate docs there.
   Run from a site directory to auto-detect the linked foundation
   and generate docs in the site folder for convenience.
+  Run from workspace root to auto-detect foundations (prompts if multiple).
 `)
 }
 
@@ -157,8 +172,45 @@ export async function docs(args) {
   let foundationDir = projectDir
   let outputDir = projectDir
 
+  // If --target specified, use it directly
+  if (options.target) {
+    foundationDir = resolve(projectDir, options.target)
+    outputDir = foundationDir
+    if (!isFoundation(foundationDir)) {
+      error(`Target directory does not appear to be a foundation: ${options.target}`)
+      log(`${colors.dim}Foundations have a src/components/ directory.${colors.reset}`)
+      process.exit(1)
+    }
+    info(`Using foundation: ${options.target}`)
+  }
+  // Check if we're at workspace root
+  else if (isWorkspaceRoot(projectDir)) {
+    const foundations = await findFoundations(projectDir)
+
+    if (foundations.length === 0) {
+      error('No foundations found in this workspace.')
+      log(`${colors.dim}Foundations have @uniweb/build in devDependencies.${colors.reset}`)
+      process.exit(1)
+    }
+
+    let targetFoundation
+    if (foundations.length === 1) {
+      targetFoundation = foundations[0]
+      info(`Found foundation: ${targetFoundation}`)
+    } else {
+      log(`${colors.dim}Multiple foundations found in workspace.${colors.reset}\n`)
+      targetFoundation = await promptSelect('Select foundation:', foundations)
+      if (!targetFoundation) {
+        log('Cancelled.')
+        process.exit(0)
+      }
+    }
+
+    foundationDir = resolve(projectDir, targetFoundation)
+    outputDir = foundationDir
+  }
   // Check if we're in a site directory
-  if (isSite(projectDir)) {
+  else if (isSite(projectDir)) {
     const foundation = await resolveFoundationFromSite(projectDir)
     if (!foundation) {
       error('Could not find a linked foundation in this site.')

package/src/commands/i18n.js

@@ -4,15 +4,24 @@
  * Commands for managing site content internationalization.
  *
  * Usage:
- *   uniweb i18n extract      Extract translatable strings to manifest
- *   uniweb i18n sync         Sync manifest with content changes
- *   uniweb i18n status       Show translation coverage per locale
+ *   uniweb i18n extract           Extract translatable strings to manifest
+ *   uniweb i18n sync              Sync manifest with content changes
+ *   uniweb i18n status            Show translation coverage per locale
+ *   uniweb i18n --target <path>   Specify site directory explicitly
+ *
+ * When run from workspace root, auto-detects sites. If multiple exist,
+ * prompts for selection.
  */
 
 import { resolve, join } from 'path'
 import { existsSync } from 'fs'
 import { readFile } from 'fs/promises'
 import yaml from 'js-yaml'
+import {
+  isWorkspaceRoot,
+  findSites,
+  promptSelect,
+} from '../utils/workspace.js'
 
 // Colors for terminal output
 const colors = {
@@ -41,6 +50,21 @@ function error(message) {
   console.error(`${colors.red}✗${colors.reset} ${message}`)
 }
 
+/**
+ * Parse --target option from args
+ */
+function parseTargetOption(args) {
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--target' || args[i] === '-t') {
+      return {
+        target: args[i + 1],
+        remainingArgs: [...args.slice(0, i), ...args.slice(i + 2)],
+      }
+    }
+  }
+  return { target: null, remainingArgs: args }
+}
+
 /**
  * Main i18n command handler
  * @param {string[]} args - Command arguments
@@ -48,13 +72,21 @@ function error(message) {
 export async function i18n(args) {
   const subcommand = args[0]
 
-  if (!subcommand || subcommand === '--help' || subcommand === '-h') {
+  if (subcommand === '--help' || subcommand === '-h') {
     showHelp()
     return
   }
 
+  // Parse --target option
+  const { target, remainingArgs } = parseTargetOption(args)
+
+  // Default to 'sync' if no subcommand (or if first arg is an option)
+  const firstArg = remainingArgs[0]
+  const effectiveSubcommand = !firstArg || firstArg.startsWith('-') ? 'sync' : firstArg
+  const effectiveArgs = !firstArg || firstArg.startsWith('-') ? remainingArgs : remainingArgs.slice(1)
+
   // Find site root
-  const siteRoot = await findSiteRoot()
+  const siteRoot = await findSiteRoot(target)
   if (!siteRoot) {
     error('Could not find site root. Make sure you are in a Uniweb site directory.')
     process.exit(1)
@@ -63,18 +95,18 @@ export async function i18n(args) {
   // Load site config for locale settings
   const config = await loadSiteConfig(siteRoot)
 
-  switch (subcommand) {
+  switch (effectiveSubcommand) {
     case 'extract':
-      await runExtract(siteRoot, config, args.slice(1))
+      await runExtract(siteRoot, config, effectiveArgs)
       break
     case 'sync':
-      await runSync(siteRoot, config, args.slice(1))
+      await runSync(siteRoot, config, effectiveArgs)
       break
     case 'status':
-      await runStatus(siteRoot, config, args.slice(1))
+      await runStatus(siteRoot, config, effectiveArgs)
       break
     default:
-      error(`Unknown subcommand: ${subcommand}`)
+      error(`Unknown subcommand: ${effectiveSubcommand}`)
       showHelp()
       process.exit(1)
   }
@@ -82,11 +114,52 @@ export async function i18n(args) {
 
 /**
  * Find site root by looking for site.yml
+ * Handles: explicit target, workspace root detection, or walking up directories
+ *
+ * @param {string|null} target - Explicit target path (from --target option)
  */
-async function findSiteRoot() {
-  let dir = process.cwd()
+async function findSiteRoot(target) {
+  const cwd = process.cwd()
+
+  // If explicit target specified, use it
+  if (target) {
+    const targetPath = resolve(cwd, target)
+    if (existsSync(join(targetPath, 'site.yml'))) {
+      return targetPath
+    }
+    error(`Target directory does not appear to be a site: ${target}`)
+    log(`${colors.dim}Sites have a site.yml file.${colors.reset}`)
+    process.exit(1)
+  }
+
+  // Check if we're at workspace root
+  if (isWorkspaceRoot(cwd)) {
+    const sites = await findSites(cwd)
+
+    if (sites.length === 0) {
+      error('No sites found in this workspace.')
+      log(`${colors.dim}Sites have @uniweb/runtime in dependencies.${colors.reset}`)
+      process.exit(1)
+    }
 
-  // Check current directory and parents
+    let targetSite
+    if (sites.length === 1) {
+      targetSite = sites[0]
+      log(`${colors.cyan}→${colors.reset} Found site: ${targetSite}`)
+    } else {
+      log(`${colors.dim}Multiple sites found in workspace.${colors.reset}\n`)
+      targetSite = await promptSelect('Select site:', sites)
+      if (!targetSite) {
+        log('Cancelled.')
+        process.exit(0)
+      }
+    }
+
+    return resolve(cwd, targetSite)
+  }
+
+  // Walk up directories looking for site.yml
+  let dir = cwd
   for (let i = 0; i < 5; i++) {
     if (existsSync(join(dir, 'site.yml'))) {
       return dir
@@ -278,16 +351,18 @@ ${colors.cyan}${colors.bright}Uniweb i18n${colors.reset}
 Site content internationalization commands.
 
 ${colors.bright}Usage:${colors.reset}
-  uniweb i18n <command> [options]
+  uniweb i18n [command] [options]
 
 ${colors.bright}Commands:${colors.reset}
+  (default)    Same as sync - extract/update strings (runs if no command given)
   extract      Extract translatable strings to locales/manifest.json
   sync         Update manifest with content changes (detects moved/changed content)
   status       Show translation coverage per locale
 
 ${colors.bright}Options:${colors.reset}
-  --verbose    Show detailed output
-  --dry-run    (sync) Show changes without writing files
+  -t, --target <path>  Site directory (auto-detected if not specified)
+  --verbose            Show detailed output
+  --dry-run            (sync) Show changes without writing files
 
 ${colors.bright}Configuration:${colors.reset}
   Optional site.yml settings:
@@ -301,7 +376,7 @@ ${colors.bright}Configuration:${colors.reset}
 
 ${colors.bright}Workflow:${colors.reset}
   1. Build your site:           uniweb build
-  2. Extract strings:           uniweb i18n extract
+  2. Extract strings:           uniweb i18n
   3. Translate locale files:    Edit locales/es.json, locales/fr.json, etc.
   4. Build with translations:   uniweb build (generates locale-specific output)
 
@@ -319,6 +394,11 @@ ${colors.bright}Examples:${colors.reset}
   uniweb i18n sync --dry-run       # Preview changes without writing
   uniweb i18n status               # Show coverage for all locales
   uniweb i18n status es            # Show coverage for Spanish only
+  uniweb i18n --target site        # Specify site directory explicitly
+
+${colors.bright}Notes:${colors.reset}
+  Run from a site directory to operate on that site.
+  Run from workspace root to auto-detect sites (prompts if multiple).
 `)
 }
 

package/src/templates/processor.js

@@ -197,15 +197,16 @@ async function processFile(sourcePath, targetPath, data, options = {}) {
  * @param {Object} options - Processing options
  * @param {string|null} options.variant - Template variant to use
  * @param {string|null} options.basePath - Base template to merge with (files copied first)
+ * @param {boolean} options.isBase - Internal: true when processing base template (allows overwriting)
  * @param {Function} options.onWarning - Warning callback
  * @param {Function} options.onProgress - Progress callback
  */
 export async function copyTemplateDirectory(sourcePath, targetPath, data, options = {}) {
-  const { variant = null, basePath = null, onWarning, onProgress } = options
+  const { variant = null, basePath = null, isBase = false, onWarning, onProgress } = options
 
-  // If a base template is specified, copy it first (without the basePath option to avoid recursion)
+  // If a base template is specified, copy it first (with isBase=true so main can overwrite)
   if (basePath && existsSync(basePath)) {
-    await copyTemplateDirectory(basePath, targetPath, data, { variant, onWarning, onProgress })
+    await copyTemplateDirectory(basePath, targetPath, data, { variant, isBase: true, onWarning, onProgress })
   }
 
   await fs.mkdir(targetPath, { recursive: true })
@@ -223,7 +224,7 @@ export async function copyTemplateDirectory(sourcePath, targetPath, data, option
   }
 
   // Options for recursive calls (without basePath to avoid re-copying base at each level)
-  const recursionOptions = { variant, onWarning, onProgress }
+  const recursionOptions = { variant, isBase, onWarning, onProgress }
 
   for (const entry of entries) {
     const sourceName = entry.name
@@ -279,11 +280,9 @@ export async function copyTemplateDirectory(sourcePath, targetPath, data, option
       const sourceFullPath = path.join(sourcePath, sourceName)
       const targetFullPath = path.join(targetPath, targetName)
 
-      // Skip if target already exists (don't overwrite)
-      if (existsSync(targetFullPath)) {
-        if (onWarning) {
-          onWarning(`Skipping ${targetFullPath} - file already exists`)
-        }
+      // When processing base template, skip if target exists (main template files take precedence)
+      // When processing main template, overwrite any files from base
+      if (isBase && existsSync(targetFullPath)) {
         continue
       }
 

package/src/utils/workspace.js

@@ -0,0 +1,189 @@
+/**
+ * Workspace Detection Utilities
+ *
+ * Detects pnpm workspace structure and classifies packages as foundations or sites.
+ * Used by commands to auto-detect targets when run from workspace root.
+ */
+
+import { existsSync, readdirSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { resolve, dirname, join } from 'node:path'
+import yaml from 'js-yaml'
+
+/**
+ * Find workspace root by looking for pnpm-workspace.yaml
+ * @param {string} startDir - Directory to start searching from
+ * @returns {string|null} - Workspace root path or null
+ */
+export function findWorkspaceRoot(startDir = process.cwd()) {
+  let dir = startDir
+  while (dir !== dirname(dir)) {
+    if (existsSync(join(dir, 'pnpm-workspace.yaml'))) {
+      return dir
+    }
+    dir = dirname(dir)
+  }
+  return null
+}
+
+/**
+ * Resolve workspace package patterns to actual directories
+ * Handles patterns like: "foundation", "site", "foundations/*", "sites/*"
+ *
+ * @param {string[]} patterns - Array of patterns from pnpm-workspace.yaml
+ * @param {string} workspaceRoot - Workspace root directory
+ * @returns {string[]} - Array of existing package directories (relative paths)
+ */
+function resolvePatterns(patterns, workspaceRoot) {
+  const packages = []
+
+  for (const pattern of patterns) {
+    // Remove quotes if present
+    const cleanPattern = pattern.replace(/^["']|["']$/g, '')
+
+    if (cleanPattern.endsWith('/*')) {
+      // Glob pattern like "foundations/*" - list subdirectories
+      const baseDir = cleanPattern.slice(0, -2)
+      const fullPath = join(workspaceRoot, baseDir)
+
+      if (existsSync(fullPath)) {
+        try {
+          const entries = readdirSync(fullPath, { withFileTypes: true })
+          for (const entry of entries) {
+            if (entry.isDirectory() && !entry.name.startsWith('.')) {
+              packages.push(join(baseDir, entry.name))
+            }
+          }
+        } catch {
+          // Ignore read errors
+        }
+      }
+    } else {
+      // Direct path like "foundation" or "site"
+      const fullPath = join(workspaceRoot, cleanPattern)
+      if (existsSync(fullPath)) {
+        packages.push(cleanPattern)
+      }
+    }
+  }
+
+  return packages
+}
+
+/**
+ * Get workspace packages from pnpm-workspace.yaml
+ * @param {string} workspaceRoot
+ * @returns {Promise<string[]>} - Array of package directories (relative paths)
+ */
+export async function getWorkspacePackages(workspaceRoot) {
+  const configPath = join(workspaceRoot, 'pnpm-workspace.yaml')
+  const content = await readFile(configPath, 'utf-8')
+  const config = yaml.load(content)
+
+  if (!config?.packages || !Array.isArray(config.packages)) {
+    return []
+  }
+
+  return resolvePatterns(config.packages, workspaceRoot)
+}
+
+/**
+ * Classify a package as foundation, site, or unknown
+ *
+ * Classification logic:
+ * - Site: has @uniweb/runtime in dependencies (checked first, more specific)
+ * - Foundation: has @uniweb/build in devDependencies but NOT @uniweb/runtime
+ *
+ * Note: Sites also have @uniweb/build for the Vite plugin, so we check
+ * for @uniweb/runtime first to distinguish them.
+ *
+ * @param {string} packagePath - Full path to package directory
+ * @returns {Promise<'foundation'|'site'|null>}
+ */
+export async function classifyPackage(packagePath) {
+  const pkgJsonPath = join(packagePath, 'package.json')
+  if (!existsSync(pkgJsonPath)) return null
+
+  try {
+    const pkg = JSON.parse(await readFile(pkgJsonPath, 'utf-8'))
+
+    // Site: has @uniweb/runtime in dependencies (check first - more specific)
+    if (pkg.dependencies?.['@uniweb/runtime']) {
+      return 'site'
+    }
+    // Foundation: has @uniweb/build in devDependencies (and not a site)
+    if (pkg.devDependencies?.['@uniweb/build']) {
+      return 'foundation'
+    }
+  } catch {
+    // Ignore parse errors
+  }
+
+  return null
+}
+
+/**
+ * Find all foundations in workspace
+ * @param {string} workspaceRoot
+ * @returns {Promise<string[]>} - Array of foundation paths (relative to workspace root)
+ */
+export async function findFoundations(workspaceRoot) {
+  const packages = await getWorkspacePackages(workspaceRoot)
+  const foundations = []
+
+  for (const pkg of packages) {
+    const fullPath = join(workspaceRoot, pkg)
+    if ((await classifyPackage(fullPath)) === 'foundation') {
+      foundations.push(pkg)
+    }
+  }
+
+  return foundations
+}
+
+/**
+ * Find all sites in workspace
+ * @param {string} workspaceRoot
+ * @returns {Promise<string[]>} - Array of site paths (relative to workspace root)
+ */
+export async function findSites(workspaceRoot) {
+  const packages = await getWorkspacePackages(workspaceRoot)
+  const sites = []
+
+  for (const pkg of packages) {
+    const fullPath = join(workspaceRoot, pkg)
+    if ((await classifyPackage(fullPath)) === 'site') {
+      sites.push(pkg)
+    }
+  }
+
+  return sites
+}
+
+/**
+ * Check if current directory is the workspace root
+ * @param {string} dir - Directory to check
+ * @returns {boolean}
+ */
+export function isWorkspaceRoot(dir = process.cwd()) {
+  return existsSync(join(dir, 'pnpm-workspace.yaml'))
+}
+
+/**
+ * Interactive prompt to select from multiple options
+ * @param {string} message - Prompt message
+ * @param {string[]} choices - Array of choices
+ * @returns {Promise<string|null>} - Selected choice or null if cancelled
+ */
+export async function promptSelect(message, choices) {
+  const prompts = (await import('prompts')).default
+
+  const response = await prompts({
+    type: 'select',
+    name: 'value',
+    message,
+    choices: choices.map(c => ({ title: c, value: c })),
+  })
+
+  return response.value || null
+}

package/templates/_shared/package.json.hbs

@@ -9,7 +9,8 @@
     "preview": "pnpm --filter site preview"
   },
   "devDependencies": {
-    "@types/node": "^22.0.0"
+    "@types/node": "^22.0.0",
+    "uniweb": "{{version "uniweb"}}"
   },
   "workspaces": [
     "site",

package/templates/multi/foundations/default/package.json.hbs

@@ -31,7 +31,6 @@
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "tailwindcss": "^4.0.0",
-    "uniweb": "{{version "uniweb"}}",
     "vite": "^7.0.0",
     "vite-plugin-svgr": "^4.2.0"
   }

package/templates/multi/foundations/default/src/_entry.generated.js

@@ -10,4 +10,5 @@ export { Section }
 
 export const capabilities = null
 
+// Per-component runtime metadata (from meta.js)
 export const meta = {}

package/templates/multi/foundations/default/src/styles.css

@@ -1,6 +1,7 @@
 @import "tailwindcss";
 
 @source "./components/**/*.{js,jsx}";
+@source "../node_modules/@uniweb/kit/src/**/*.{js,jsx}";
 
 @theme {
   --color-primary: #3b82f6;

package/templates/multi/package.json.hbs

@@ -11,7 +11,8 @@
     "preview": "pnpm --filter main preview"
   },
   "devDependencies": {
-    "@types/node": "^22.0.0"
+    "@types/node": "^22.0.0",
+    "uniweb": "{{version "uniweb"}}"
   },
   "workspaces": [
     "site",

package/templates/multi/sites/main/package.json.hbs

@@ -6,7 +6,7 @@
   "scripts": {
     "dev": "vite",
     "dev:runtime": "VITE_FOUNDATION_MODE=runtime vite",
-    "build": "npx uniweb@latest build",
+    "build": "uniweb build",
     "preview": "vite preview"
   },
   "dependencies": {

package/templates/multi/template.json

@@ -1,4 +1,5 @@
 {
   "name": "Multi-Site Workspace",
-  "description": "A Uniweb workspace supporting multiple sites and foundations. Use this when you need to manage several related sites or share foundations across projects."
+  "description": "A Uniweb workspace supporting multiple sites and foundations. Use this when you need to manage several related sites or share foundations across projects.",
+  "base": "_shared"
 }

package/templates/single/foundation/package.json.hbs

@@ -31,7 +31,6 @@
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "tailwindcss": "^4.0.0",
-    "uniweb": "{{version "uniweb"}}",
     "vite": "^7.0.0",
     "vite-plugin-svgr": "^4.2.0"
   }

package/templates/single/foundation/src/_entry.generated.js

@@ -10,4 +10,5 @@ export { Section }
 
 export const capabilities = null
 
+// Per-component runtime metadata (from meta.js)
 export const meta = {}

package/templates/single/foundation/src/styles.css

@@ -1,6 +1,7 @@
 @import "tailwindcss";
 
 @source "./components/**/*.{js,jsx}";
+@source "../node_modules/@uniweb/kit/src/**/*.{js,jsx}";
 
 @theme {
   --color-primary: #3b82f6;

package/templates/single/site/package.json.hbs

@@ -6,7 +6,7 @@
   "scripts": {
     "dev": "vite",
     "dev:runtime": "VITE_FOUNDATION_MODE=runtime vite",
-    "build": "npx uniweb@latest build",
+    "build": "uniweb build",
     "preview": "vite preview"
   },
   "dependencies": {