uniweb 1.0.2 → 1.2.0

package/src/framework-index.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-13T14:23:15.630Z",
+  "generatedAt": "2026-10-13T20:52:47.988Z",
   "packages": {
     "@uniweb/api": {
-      "version": "1.0.1"
+      "version": "1.1.0"
     },
     "@uniweb/build": {
-      "version": "1.0.1"
+      "version": "1.1.1"
     },
     "@uniweb/content-reader": {
       "version": "1.2.8"
@@ -15,28 +15,28 @@
       "version": "1.0.1"
     },
     "@uniweb/core": {
-      "version": "1.0.1"
+      "version": "1.1.0"
     },
     "@uniweb/frame-bridge": {
-      "version": "1.0.1"
+      "version": "1.0.2"
     },
     "@uniweb/icons": {
-      "version": "1.0.1"
+      "version": "1.0.2"
     },
     "@uniweb/kit": {
-      "version": "1.0.1"
+      "version": "1.1.0"
     },
     "@uniweb/loom": {
-      "version": "1.0.1"
+      "version": "1.1.0"
     },
     "@uniweb/press": {
-      "version": "1.0.1"
+      "version": "1.1.0"
     },
     "@uniweb/projections": {
-      "version": "1.0.1"
+      "version": "1.1.0"
     },
     "@uniweb/runtime": {
-      "version": "1.0.2"
+      "version": "1.1.0"
     },
     "@uniweb/scene": {
       "version": "1.0.1"
@@ -45,22 +45,22 @@
       "version": "1.0.1"
     },
     "@uniweb/scholar": {
-      "version": "1.0.1"
+      "version": "1.1.0"
     },
     "@uniweb/semantic-parser": {
       "version": "1.5.1"
     },
     "@uniweb/snapshot": {
-      "version": "1.0.1"
+      "version": "1.1.0"
     },
     "@uniweb/templates": {
-      "version": "1.0.1"
+      "version": "1.1.0"
     },
     "@uniweb/theming": {
-      "version": "1.0.1"
+      "version": "1.1.0"
     },
     "@uniweb/unipress": {
-      "version": "1.0.2"
+      "version": "1.1.0"
     }
   },
   "templates": {

package/src/utils/config.js

@@ -18,10 +18,16 @@ import { existsSync, readFileSync } from 'node:fs'
 import { readFile, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
-import yaml from 'js-yaml'
 import { filterCmd } from './pm.js'
 import { writeJsonPreservingStyleAsync } from './json-file.js'
 import { loggedInOriginOf, readSessionFileSync } from './session-file.js'
+import {
+  WORKSPACE_FILE,
+  readWorkspacePatterns,
+  patternsCover,
+  editWorkspaceFilePackages,
+  renderWorkspaceFile
+} from './workspace-packages.js'
 
 // ── Backend origin ─────────────────────────────────────────────
 
@@ -214,59 +220,88 @@ export const DEFAULT_BACKEND_ORIGIN = 'https://uniweb.app'
 /**
  * Read workspace package globs.
  * Tries pnpm-workspace.yaml first, falls back to package.json workspaces.
+ * The folders they name: `workspacePackages` (./workspace-packages.js).
  * @param {string} rootDir - Workspace root directory
  * @returns {Promise<{packages: string[]}>}
  */
 export async function readWorkspaceConfig(rootDir) {
-  // Try pnpm-workspace.yaml first
-  const configPath = join(rootDir, 'pnpm-workspace.yaml')
-  if (existsSync(configPath)) {
-    const content = await readFile(configPath, 'utf-8')
-    const config = yaml.load(content)
-    return { packages: config?.packages || [] }
-  }
-
-  // Fall back to package.json workspaces
-  const pkg = await readRootPackageJson(rootDir)
-  if (Array.isArray(pkg.workspaces)) {
-    return { packages: pkg.workspaces }
-  }
-
-  return { packages: [] }
+  return { packages: readWorkspacePatterns(rootDir).patterns }
 }
 
 /**
- * Write pnpm-workspace.yaml
+ * Make the folder at `relPath` a workspace package.
+ *
+ * Nothing is written for a folder a pattern already covers — it is a package
+ * already. ⛔ Until 2026-10-13 its own path was added beside the pattern, and
+ * discovery listed it twice. Otherwise `entry` — the folder itself, unless a
+ * pattern is given for it — is added to each manifest that does not cover it:
+ *
+ * - pnpm-workspace.yaml's `packages:` list, edited in place: comments and every
+ *   other key stay as they were. ⛔ Until 2026-10-13 the file was rewritten from
+ *   its `packages` alone, deleting `onlyBuiltDependencies` and `allowBuilds` with
+ *   the comments that explain them. A workspace without the file (a blank one, at
+ *   its first `add`) gets it from the workspace template, as `create` writes it.
+ * - package.json's `workspaces`, which npm and yarn read.
+ *
  * @param {string} rootDir - Workspace root directory
- * @param {{packages: string[]}} config
+ * @param {string} relPath - The package's folder, workspace-relative
+ * @param {{ entry?: string }} [options] - `entry`: a pattern to list for it instead
  */
-export async function writeWorkspaceConfig(rootDir, config) {
-  const configPath = join(rootDir, 'pnpm-workspace.yaml')
-  const content = yaml.dump(config, { flowLevel: -1, quotingType: '"' })
-  await writeFile(configPath, content)
+export async function registerWorkspacePackage(rootDir, relPath, { entry = relPath } = {}) {
+  const { source, patterns } = readWorkspacePatterns(rootDir)
+  const ymlPath = join(rootDir, WORKSPACE_FILE)
+  if (!patternsCover(patterns, relPath)) {
+    if (source === WORKSPACE_FILE) {
+      const text = await readFile(ymlPath, 'utf-8')
+      await writeFile(ymlPath, editedWorkspaceFile(text, (list) => [...list, entry], entry))
+    } else {
+      await writeFile(ymlPath, renderWorkspaceFile([...patterns, entry]))
+    }
+  }
+
+  const pkg = await readRootPackageJson(rootDir)
+  const workspaces = Array.isArray(pkg.workspaces) ? pkg.workspaces : []
+  if (!patternsCover(workspaces, relPath)) {
+    pkg.workspaces = [...workspaces, entry]
+    await writeRootPackageJson(rootDir, pkg)
+  }
 }
 
 /**
- * Add a glob pattern to pnpm-workspace.yaml if not already present
- * @param {string} rootDir - Workspace root directory
- * @param {string} glob - Glob pattern to add
+ * A package folder moved from `oldPath` to `newPath`: rename its entry in each
+ * manifest that lists it by path — a pattern is left as written — then register
+ * the new path, in case it has moved out from under the pattern that covered it.
+ *
+ * @param {string} rootDir
+ * @param {string} oldPath
+ * @param {string} newPath
  */
-export async function addWorkspaceGlob(rootDir, glob) {
-  const config = await readWorkspaceConfig(rootDir)
-  if (!config.packages.includes(glob)) {
-    config.packages.push(glob)
-    await writeWorkspaceConfig(rootDir, config)
+export async function moveWorkspacePackage(rootDir, oldPath, newPath) {
+  const { source, patterns } = readWorkspacePatterns(rootDir)
+  if (source === WORKSPACE_FILE && patterns.includes(oldPath)) {
+    const ymlPath = join(rootDir, WORKSPACE_FILE)
+    const text = await readFile(ymlPath, 'utf-8')
+    const rename = (list) => list.map((p) => (p === oldPath ? newPath : p))
+    await writeFile(ymlPath, editedWorkspaceFile(text, rename, newPath))
   }
-
-  // Sync workspaces array in package.json (for npm compatibility)
   const pkg = await readRootPackageJson(rootDir)
-  if (!pkg.workspaces) {
-    pkg.workspaces = []
-  }
-  if (!pkg.workspaces.includes(glob)) {
-    pkg.workspaces.push(glob)
+  if (Array.isArray(pkg.workspaces) && pkg.workspaces.includes(oldPath)) {
+    pkg.workspaces = pkg.workspaces.map((p) => (p === oldPath ? newPath : p))
     await writeRootPackageJson(rootDir, pkg)
   }
+  await registerWorkspacePackage(rootDir, newPath)
+}
+
+/** The edited file, or an error that says what to add by hand — the file is never rewritten. */
+function editedWorkspaceFile(text, edit, entry) {
+  const next = editWorkspaceFilePackages(text, edit)
+  if (next == null) {
+    throw new Error(
+      `Could not edit the packages: list in ${WORKSPACE_FILE} in place, and it is not rewritten ` +
+        `whole. Add "${entry}" to it by hand.`
+    )
+  }
+  return next
 }
 
 /**
@@ -352,66 +387,39 @@ export function computeRootScripts(sites, pm = 'pnpm') {
  */
 export async function updateRootScripts(rootDir, sites, pm = 'pnpm') {
   const pkg = await readRootPackageJson(rootDir)
-  const newScripts = computeRootScripts(sites, pm)
+  const unique = sites.filter((s, i) => sites.findIndex((o) => o.path === s.path) === i)
+  const newScripts = computeRootScripts(unique, pm)
+  const scripts = { ...(pkg.scripts || {}) }
 
   // If we're adding a second site, rename existing dev/preview to dev:{firstName}
-  if (sites.length === 2 && pkg.scripts?.dev) {
-    const firstName = sites[0].name
+  if (unique.length === 2 && scripts.dev) {
+    const firstName = unique[0].name
     // Only rename if the existing dev script references the first site's name
-    if (pkg.scripts.dev.includes(firstName)) {
-      pkg.scripts[`dev:${firstName}`] = pkg.scripts.dev
-      pkg.scripts[`preview:${firstName}`] = pkg.scripts.preview
-    }
-  }
-
-  pkg.scripts = { ...pkg.scripts, ...newScripts }
-  await writeRootPackageJson(rootDir, pkg)
-}
-
-// Resolve a workspace glob pattern to actual directories
-export async function resolveGlob(rootDir, pattern) {
-  const clean = pattern.replace(/^["']|["']$/g, '')
-
-  if (clean.endsWith('/*')) {
-    // Pattern like "foundations/*" - list subdirectories
-    const baseDir = clean.slice(0, -2)
-    const fullPath = join(rootDir, baseDir)
-    if (!existsSync(fullPath)) return []
-    try {
-      const { readdirSync } = await import('node:fs')
-      const entries = readdirSync(fullPath, { withFileTypes: true })
-      return entries
-        .filter((e) => e.isDirectory() && !e.name.startsWith('.'))
-        .map((e) => join(baseDir, e.name))
-    } catch {
-      return []
+    if (scripts.dev.includes(firstName)) {
+      scripts[`dev:${firstName}`] = scripts.dev
+      scripts[`preview:${firstName}`] = scripts.preview
     }
   }
 
-  if (clean.startsWith('*/')) {
-    // Pattern like "*/foundation" - find subdirs with this child
-    const suffix = clean.slice(2)
-    const { readdirSync } = await import('node:fs')
-    try {
-      const entries = readdirSync(rootDir, { withFileTypes: true })
-      return entries
-        .filter(
-          (e) =>
-            e.isDirectory() &&
-            !e.name.startsWith('.') &&
-            e.name !== 'node_modules'
-        )
-        .filter((e) => existsSync(join(rootDir, e.name, suffix)))
-        .map((e) => join(e.name, suffix))
-    } catch {
-      return []
-    }
+  // ⭐ The per-site scripts this CLI writes are regenerated from the sites there are
+  // now, and one it wrote for a site that is gone — renamed, moved, removed — goes.
+  // A script whose command is not one the CLI writes is the user's, and stays.
+  // ⛔ Until 2026-10-13 they were only ever added: after `rename site blog journal`,
+  // `dev:blog` still ran `uniweb dev blog`, a site that no longer existed.
+  for (const [key, value] of Object.entries(scripts)) {
+    if (key in newScripts) continue
+    const m = /^(dev|preview):(.+)$/.exec(key)
+    if (m && cliSiteScripts(m[1], m[2]).includes(value)) delete scripts[key]
   }
 
-  // Direct path like "foundation" or "site"
-  if (existsSync(join(rootDir, clean))) {
-    return [clean]
-  }
+  pkg.scripts = { ...scripts, ...newScripts }
+  await writeRootPackageJson(rootDir, pkg)
+}
 
-  return []
+/** Every command this CLI has written for the `dev:<site>` / `preview:<site>` script. */
+function cliSiteScripts(kind, site) {
+  return kind === 'dev'
+    ? [`uniweb dev ${site}`, filterCmd('pnpm', site, 'dev'), filterCmd('npm', site, 'dev')]
+    : [filterCmd('pnpm', site, 'preview'), filterCmd('npm', site, 'preview')]
 }
+

package/src/utils/discover.js

@@ -24,7 +24,7 @@ import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { classifyPackage } from '@uniweb/build'
-import { readWorkspaceConfig, resolveGlob } from './config.js'
+import { workspacePackages } from './workspace-packages.js'
 
 /**
  * Discover foundations in the workspace.
@@ -45,30 +45,27 @@ export async function discoverSites(rootDir) {
 }
 
 async function discoverByKind(rootDir, kind) {
-  const { packages } = await readWorkspaceConfig(rootDir)
   const out = []
 
-  for (const pattern of packages) {
-    const dirs = await resolveGlob(rootDir, pattern)
-    for (const dir of dirs) {
-      const fullPath = join(rootDir, dir)
-      if (classifyPackage(fullPath) !== kind) continue
+  // The workspace's packages as pnpm reads its patterns — each folder once.
+  for (const dir of workspacePackages(rootDir)) {
+    const fullPath = join(rootDir, dir)
+    if (classifyPackage(fullPath) !== kind) continue
 
-      // Read package.json for the package name. Synthesize one from
-      // the directory if it's missing or malformed — we still want
-      // the package to surface in pickers.
-      const pkgPath = join(fullPath, 'package.json')
-      let name = dir.split('/').pop()
-      if (existsSync(pkgPath)) {
-        try {
-          const pkg = JSON.parse(await readFile(pkgPath, 'utf-8'))
-          if (pkg.name) name = pkg.name
-        } catch {
-          // keep directory-derived name
-        }
+    // Read package.json for the package name. Synthesize one from
+    // the directory if it's missing or malformed — we still want
+    // the package to surface in pickers.
+    const pkgPath = join(fullPath, 'package.json')
+    let name = dir.split('/').pop()
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(await readFile(pkgPath, 'utf-8'))
+        if (pkg.name) name = pkg.name
+      } catch {
+        // keep directory-derived name
       }
-      out.push({ name, path: dir })
     }
+    out.push({ name, path: dir })
   }
 
   return out

package/src/utils/placement.js

@@ -96,6 +96,12 @@ export const EXTENSION_KIND = {
  * @returns {{ relativePath: string, packageName: string }}
  */
 export function resolvePlacement(rootDir, name, opts, kind) {
+  // 0. `--project` names the folder itself (rule 4), so a name or a `--path` beside it
+  //    names a second one: refused, never ignored (`projectConflictLines`).
+  if (opts.project && (name || opts.path)) {
+    return { projectConflict: true, relativePath: null, packageName: null }
+  }
+
   // 1. --path is a PARENT directory. The folder is `<path>/<name>` if a
   //    name was given, or `<path>` itself if not (the path's last segment
   //    is then taken as the package name).
@@ -149,3 +155,52 @@ export function resolvePlacement(rootDir, name, opts, kind) {
     packageName: kind.defaultPkg
   }
 }
+
+/**
+ * What to say when `--project` came with a name or a `--path` — the first line an
+ * error, the rest the commands that do what was meant.
+ *
+ * `--project <p>` is the co-located shorthand: it places a project's one foundation
+ * at `<p>/src/` and its one site at `<p>/site/`, and names nothing else. A name beside
+ * it asks for a different folder, which naming the folder says plainly.
+ * ⛔ Until 2026-10-13 the name won without a word: `add site fitness --project
+ * memberships` created `fitness/` at the workspace root.
+ *
+ * @param {'foundation'|'site'|'extension'} kind
+ * @param {string|null} name - the name given, if any
+ * @param {{ project: string, path?: string }} opts
+ * @param {string} command - how to run the verb: `uniweb add site`, `uniweb clone <uuid>`
+ * @returns {string[]}
+ */
+export function projectConflictLines(kind, name, opts, command) {
+  const p = opts.project
+  if (!name) {
+    return [
+      `--project and --path both name the folder — use one.`,
+      `  ${command} --project ${p}      ${kind === 'site' ? `${p}/site/` : `${p}/src/`}`,
+      `  ${command} --path ${opts.path}`
+    ]
+  }
+  if (kind === 'extension') {
+    return [
+      `--project places a project's foundation or site; an extension goes in the folder you name.`,
+      `  ${command} ${p}/extensions/${name}`
+    ]
+  }
+  if (kind === 'site') {
+    return [
+      `--project ${p} places the project's one site, at ${p}/site/, and takes no name.`,
+      `For a site named "${name}" in ${p}, name its folder — a project with several sites keeps them in ${p}/sites/:`,
+      `  ${command} ${p}/sites/${name}`,
+      `Or the project's one site:`,
+      `  ${command} --project ${p}`
+    ]
+  }
+  return [
+    `--project ${p} places the project's foundation, at ${p}/src/, and takes no name.`,
+    `For a foundation named "${name}" in ${p}, name its folder:`,
+    `  ${command} ${p}/${name}`,
+    `Or the project's foundation:`,
+    `  ${command} --project ${p}`
+  ]
+}

package/src/utils/scaffold.js

@@ -37,7 +37,7 @@ export async function scaffoldWorkspace(targetDir, context, options = {}) {
   registerVersions(getVersionsForTemplates())
 
   // Skip pnpm-workspace.yaml for blank workspaces (no packages yet).
-  // The `add` command creates it on demand via addWorkspaceGlob().
+  // The `add` command creates it on demand (registerWorkspacePackage), from this template.
   // Without this, pnpm fails with ERR_PNPM_NO_IMPORTER_MANIFEST_FOUND
   // because an empty packages: [] makes pnpm search parent directories.
   const skip = context.workspaceGlobs?.length ? [] : ['pnpm-workspace.yaml']