uniweb 0.12.2 → 0.12.4

package/src/commands/rename.js

@@ -0,0 +1,310 @@
+/**
+ * Rename Command
+ *
+ * Renames packages across the workspace transactionally. Currently
+ * supports `rename foundation <old> <new>`; sites and extensions can be
+ * added with the same scaffolding when needed.
+ *
+ * What a foundation rename touches (in order):
+ *   1. The foundation's own package.json::name.
+ *   2. Folder name on disk (when folder leaf matches old package name).
+ *   3. Each site's package.json: dep key (old → new) + file: path.
+ *   4. Each site's site.yml::foundation.
+ *   5. pnpm-workspace.yaml::packages and package.json::workspaces
+ *      (when the folder rename moved the path).
+ *   6. Root scripts (`pnpm --filter <old>` references).
+ *
+ * Pre-flight checks run before any mutation. If anything would conflict
+ * (target name already taken, foundation not found, folder collision)
+ * we bail with a clear message and no partial state.
+ *
+ * Out of scope: registry side. The publish id (`package.json::uniweb.id`)
+ * is independent of the workspace name and stays untouched. Users who
+ * want to also rename on the registry run `uniweb publish --name <new>`.
+ *
+ * Usage:
+ *   uniweb rename foundation <old> <new>
+ */
+
+import { existsSync } from 'node:fs'
+import { readFile, writeFile, rename as fsRename } from 'node:fs/promises'
+import { join, relative, dirname, basename } from 'node:path'
+import yaml from 'js-yaml'
+import { findWorkspaceRoot } from '../utils/workspace.js'
+import {
+  discoverFoundations,
+  discoverSites,
+  readWorkspaceConfig,
+  writeWorkspaceConfig,
+  readRootPackageJson,
+  writeRootPackageJson,
+  updateRootScripts,
+} from '../utils/config.js'
+import { getExistingPackageNames, validatePackageName } from '../utils/names.js'
+import { detectPackageManager, installCmd } from '../utils/pm.js'
+import { getCliPrefix } from '../utils/interactive.js'
+
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+}
+
+const success = (msg) => console.log(`${colors.green}✓${colors.reset} ${msg}`)
+const error = (msg) => console.error(`${colors.red}✗${colors.reset} ${msg}`)
+const info = (msg) => console.log(`${colors.dim}${msg}${colors.reset}`)
+const log = console.log
+
+export async function rename(args = []) {
+  const [subcommand, oldName, newName] = args
+  const prefix = getCliPrefix()
+
+  if (!subcommand || subcommand === '--help' || subcommand === '-h') {
+    showHelp(prefix)
+    return
+  }
+
+  if (subcommand !== 'foundation') {
+    error(`Unknown subcommand: ${subcommand}`)
+    log(`Supported: rename foundation <old> <new>`)
+    process.exit(1)
+  }
+
+  if (!oldName || !newName) {
+    error('Missing arguments.')
+    log(`Usage: ${prefix} rename foundation <old> <new>`)
+    process.exit(1)
+  }
+
+  if (oldName === newName) {
+    error('Old and new names are identical — nothing to do.')
+    process.exit(1)
+  }
+
+  const rootDir = findWorkspaceRoot()
+  if (!rootDir) {
+    error('Not in a Uniweb workspace.')
+    log(`Run this command from your project root or a site/foundation directory.`)
+    process.exit(1)
+  }
+
+  await renameFoundation(rootDir, oldName, newName, prefix)
+}
+
+async function renameFoundation(rootDir, oldName, newName, prefix) {
+  // ─── Pre-flight ───────────────────────────────────────────────
+
+  // Validate the new name (format + reserved-name check). `src` is
+  // grandfathered in for the same reason add foundation grandfathers
+  // it (the convention for "the package that lives in src/").
+  if (newName !== 'src') {
+    const valid = validatePackageName(newName)
+    if (valid !== true) {
+      error(valid)
+      process.exit(1)
+    }
+  }
+
+  // The foundation must exist under its current name.
+  const foundations = await discoverFoundations(rootDir)
+  const target = foundations.find(f => f.name === oldName)
+  if (!target) {
+    error(`No foundation named ${colors.bright}${oldName}${colors.reset} in this workspace.`)
+    if (foundations.length > 0) {
+      log(`Available: ${foundations.map(f => f.name).join(', ')}`)
+    }
+    process.exit(1)
+  }
+
+  // The new name must be free across the entire workspace.
+  const existingNames = await getExistingPackageNames(rootDir)
+  if (existingNames.has(newName)) {
+    error(`Cannot rename: a package named ${colors.bright}${newName}${colors.reset} already exists in this workspace.`)
+    process.exit(1)
+  }
+
+  const oldFoundationPath = target.path  // workspace-relative
+  const oldFoundationDir = join(rootDir, oldFoundationPath)
+  const folderLeaf = basename(oldFoundationPath)
+
+  // Decide the new folder path. Rule: if the folder leaf matches the
+  // old package name, rename the leaf to match the new package name
+  // (preserving any parent dirs like `foundations/`). Otherwise leave
+  // the folder alone — the user named the folder differently than the
+  // package, and we honor that.
+  let newFoundationPath = oldFoundationPath
+  let newFoundationDir = oldFoundationDir
+  const folderWillRename = folderLeaf === oldName
+  if (folderWillRename) {
+    const parent = dirname(oldFoundationPath)
+    newFoundationPath = parent === '.' ? newName : join(parent, newName)
+    newFoundationDir = join(rootDir, newFoundationPath)
+    if (existsSync(newFoundationDir)) {
+      error(`Cannot rename: target folder ${colors.bright}${newFoundationPath}/${colors.reset} already exists.`)
+      process.exit(1)
+    }
+  }
+
+  // Find every site that depends on the foundation. Two signals must
+  // agree: site.yml::foundation === oldName AND package.json has the
+  // dep key. If they disagree (which doctor would have flagged) we
+  // still rename whichever signals point to the old name — the goal
+  // is to leave the workspace consistent under the new name.
+  const sites = await discoverSites(rootDir)
+  const affectedSites = []
+  for (const site of sites) {
+    const sitePkgPath = join(rootDir, site.path, 'package.json')
+    const siteYmlPath = join(rootDir, site.path, 'site.yml')
+    let pkg, ymlText, ymlData
+    try {
+      pkg = JSON.parse(await readFile(sitePkgPath, 'utf-8'))
+    } catch {
+      pkg = null
+    }
+    try {
+      ymlText = await readFile(siteYmlPath, 'utf-8')
+      ymlData = yaml.load(ymlText) || {}
+    } catch {
+      ymlText = null
+      ymlData = null
+    }
+    const hasDep = pkg?.dependencies && oldName in pkg.dependencies
+    const ymlMatches = ymlData?.foundation === oldName
+    if (hasDep || ymlMatches) {
+      affectedSites.push({
+        path: site.path,
+        name: site.name,
+        pkg,
+        sitePkgPath,
+        siteYmlPath,
+        ymlData,
+        hasDep,
+        ymlMatches,
+      })
+    }
+  }
+
+  // Read workspace config + root package.json once. Both manifests
+  // are kept in sync by addWorkspaceGlob; we update both here too
+  // (the multi-PM compatibility invariant).
+  const wsConfig = await readWorkspaceConfig(rootDir)
+  const rootPkg = await readRootPackageJson(rootDir)
+
+  // ─── Print plan, then execute ────────────────────────────────
+
+  log('')
+  log(`${colors.bright}Rename foundation${colors.reset}: ${colors.yellow}${oldName}${colors.reset} → ${colors.green}${newName}${colors.reset}`)
+  log('')
+  if (folderWillRename) {
+    info(`  Folder:  ${oldFoundationPath}/  →  ${newFoundationPath}/`)
+  } else {
+    info(`  Folder:  ${oldFoundationPath}/  (unchanged — leaf doesn't match package name)`)
+  }
+  info(`  package.json::name:  "${oldName}"  →  "${newName}"`)
+  if (affectedSites.length === 0) {
+    info(`  Sites depending on this foundation: none`)
+  } else {
+    info(`  Sites depending on this foundation:`)
+    for (const s of affectedSites) {
+      info(`    • ${s.name} at ${s.path}/`)
+    }
+  }
+  log('')
+
+  // 1. Rename the folder (if applicable). Do this first because every
+  //    later write needs paths under the new location.
+  if (folderWillRename) {
+    await fsRename(oldFoundationDir, newFoundationDir)
+  }
+
+  // 2. Rewrite the foundation's package.json::name.
+  const fndPkgPath = join(newFoundationDir, 'package.json')
+  const fndPkg = JSON.parse(await readFile(fndPkgPath, 'utf-8'))
+  fndPkg.name = newName
+  await writeFile(fndPkgPath, JSON.stringify(fndPkg, null, 2) + '\n')
+
+  // 3 + 4. For each affected site, update package.json deps and site.yml.
+  for (const s of affectedSites) {
+    if (s.hasDep) {
+      // Rename the dep key. Recompute the file: path against the new
+      // foundation location (the old one no longer exists if the
+      // folder was renamed).
+      const newRel = relative(join(rootDir, s.path), newFoundationDir) || '.'
+      const oldValue = s.pkg.dependencies[oldName]
+      delete s.pkg.dependencies[oldName]
+      s.pkg.dependencies[newName] = oldValue.startsWith('file:')
+        ? `file:${newRel}`
+        : oldValue  // npm-pinned, leave it; rename-then-republish would
+                    // need a separate `pnpm update` step that's out of scope.
+      await writeFile(s.sitePkgPath, JSON.stringify(s.pkg, null, 2) + '\n')
+    }
+    if (s.ymlMatches) {
+      const newYmlData = { ...s.ymlData, foundation: newName }
+      await writeFile(s.siteYmlPath, yaml.dump(newYmlData, { flowLevel: -1, quotingType: "'" }))
+    }
+  }
+
+  // 5. Update workspace manifests. Both pnpm-workspace.yaml and
+  //    package.json::workspaces (sync invariant) — only the entry
+  //    matching the old folder path moves; bare globs like
+  //    `foundations/*` don't change.
+  if (folderWillRename) {
+    if (wsConfig.packages.includes(oldFoundationPath)) {
+      const idx = wsConfig.packages.indexOf(oldFoundationPath)
+      wsConfig.packages[idx] = newFoundationPath
+      await writeWorkspaceConfig(rootDir, wsConfig)
+    }
+    if (Array.isArray(rootPkg.workspaces) && rootPkg.workspaces.includes(oldFoundationPath)) {
+      const idx = rootPkg.workspaces.indexOf(oldFoundationPath)
+      rootPkg.workspaces[idx] = newFoundationPath
+      await writeRootPackageJson(rootDir, rootPkg)
+    }
+  }
+
+  // 6. Root scripts can reference the foundation by name (e.g.
+  //    `pnpm --filter <name> build`). updateRootScripts regenerates
+  //    them from the current discoverSites output, which has fresh
+  //    names after the writes above.
+  const pm = detectPackageManager()
+  const freshSites = await discoverSites(rootDir)
+  await updateRootScripts(rootDir, freshSites, pm)
+
+  // ─── Done ─────────────────────────────────────────────────────
+
+  log('')
+  success(`Renamed foundation ${colors.bright}${oldName}${colors.reset} → ${colors.bright}${newName}${colors.reset}`)
+  log('')
+  log(`Next: ${colors.cyan}${installCmd(pm)}${colors.reset}  ${colors.dim}(refresh symlinks under the new name)${colors.reset}`)
+  log(`      ${colors.cyan}${getCliPrefix()} doctor${colors.reset}  ${colors.dim}(verify wiring)${colors.reset}`)
+}
+
+function showHelp(prefix) {
+  log(`
+${colors.cyan}${colors.bright}Uniweb Rename${colors.reset}
+
+Rename a package across the workspace, keeping all wiring in sync.
+
+${colors.bright}Usage:${colors.reset}
+  ${prefix} rename foundation <old-name> <new-name>
+
+${colors.bright}What it does (foundation):${colors.reset}
+  • Updates the foundation's package.json::name.
+  • Renames the folder if its leaf matched the old package name.
+  • Updates every site's package.json dependency key + file: path.
+  • Updates every site's site.yml::foundation reference.
+  • Updates pnpm-workspace.yaml + package.json::workspaces (kept in sync).
+  • Regenerates root scripts.
+
+${colors.bright}What it does NOT do:${colors.reset}
+  • Push to the registry. The publish id (package.json::uniweb.id) is
+    independent. To rename on the registry too, run \`${prefix} publish --name <new>\`.
+
+${colors.bright}Examples:${colors.reset}
+  ${prefix} rename foundation src marketing-src
+  ${prefix} rename foundation marketing acme-marketing
+`)
+}

package/src/framework-index.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-04-29T13:50:36.314Z",
+  "generatedAt": "2026-04-30T00:37:08.969Z",
   "packages": {
     "@uniweb/build": {
-      "version": "0.13.1",
+      "version": "0.13.3",
       "path": "framework/build",
       "deps": [
         "@uniweb/content-reader",
@@ -82,7 +82,7 @@
       "deps": []
     },
     "@uniweb/templates": {
-      "version": "0.7.36",
+      "version": "0.7.38",
       "path": "framework/templates",
       "deps": []
     },
@@ -92,7 +92,7 @@
       "deps": []
     },
     "@uniweb/unipress": {
-      "version": "0.4.1",
+      "version": "0.4.2",
       "path": "framework/unipress",
       "deps": [
         "@uniweb/build",

package/src/index.js

@@ -495,8 +495,8 @@ async function main() {
   // Handle doctor command (dynamic import — depends on @uniweb/build)
   if (command === 'doctor') {
     const { doctor } = await importProjectCommand('./commands/doctor.js')
-    await doctor(args.slice(1))
-    return
+    const result = await doctor(args.slice(1))
+    process.exit(result?.errors > 0 ? 1 : 0)
   }
 
   // Handle update command
@@ -518,6 +518,13 @@ async function main() {
     return
   }
 
+  // Handle rename command (dynamic import — depends on @uniweb/build via deps)
+  if (command === 'rename') {
+    const { rename } = await importProjectCommand('./commands/rename.js')
+    await rename(args.slice(1))
+    return
+  }
+
   // Handle publish command (dynamic import — depends on @uniweb/build)
   if (command === 'publish') {
     const { publish } = await importProjectCommand('./commands/publish.js')
@@ -815,6 +822,7 @@ ${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
+  rename <type>      Rename a workspace package (foundation today)
   build              Build the current project
   deploy             Deploy a site to Uniweb hosting
   publish            Publish a foundation to the Uniweb Registry
@@ -876,11 +884,12 @@ ${colors.bright}Deploy Options:${colors.reset}
 
 ${colors.bright}Build Options:${colors.reset}
   --target <type>    Build target (foundation, site) - auto-detected if not specified
-  --prerender        Force pre-rendering (overrides site.yml)
-  --no-prerender     Skip pre-rendering (overrides site.yml)
+  --link             Site: data-only pipeline (Uniweb-edge hosting)
+  --bundle           Site: vite-built static-host artifact (default)
+  --prerender        Force pre-rendering (bundle mode only; overrides site.yml)
+  --no-prerender     Skip pre-rendering (bundle mode only; overrides site.yml)
   --foundation-dir   Path to foundation directory (for prerendering)
   --platform <name>  Deployment platform (e.g., vercel) for platform-specific output
-  --shell            Build site without embedded content (for dynamic backend serving)
 
   At workspace root, builds all foundations first, then all sites.
   Pre-rendering is enabled by default when build.prerender: true in site.yml

package/src/utils/receipt.js

@@ -0,0 +1,91 @@
+/**
+ * `dist/publish.json` receipt — shared shape used by `publish` and `deploy`.
+ *
+ * The receipt is a per-checkout cache of the last publish; it lets the
+ * deploy verb decide whether a workspace-local foundation needs republishing
+ * without a network round-trip on the happy path. It's gitignored, so it
+ * never travels with the source — fresh clones, CI runs, and teammates all
+ * start with no cache. Both verbs refill the cache lazily by reading the
+ * registry's index when the local file is missing.
+ *
+ * See `kb/framework/build/workspace-ergonomics.md` for the full rationale.
+ */
+
+/**
+ * Compose the canonical six-field receipt body. All callers MUST go through
+ * this helper so the runbook's pp-10 schema check stays meaningful.
+ *
+ * @param {Object} params
+ * @param {string|null} params.gitSha
+ * @param {boolean} params.gitDirty
+ * @param {string} params.url
+ * @param {string} params.publishedAt
+ * @param {string} params.classification    'propagate' | 'silent'
+ * @returns {Object}
+ */
+export function composeReceipt({ gitSha, gitDirty, url, publishedAt, classification }) {
+  return {
+    schemaVersion: 1,
+    publishedFromGitSha: gitSha,
+    publishedFromGitDirty: gitDirty,
+    url,
+    publishedAt,
+    classification,
+  }
+}
+
+/**
+ * Resolve the canonical receipt URL given (in priority order):
+ *   1. A `publishResult.url` from a fresh upload — server-rendered, handles
+ *      empty-scope rewrites the CLI can't synthesize.
+ *   2. An `existingEntry.url` recorded by a previous publish (refill path).
+ *   3. A synthesized canonical form — `file://` for local registries,
+ *      `<apiUrl>/foundations/<name>@<version>/foundation.js` for remote.
+ *      The remote form mirrors the path the worker returns in `publishResult.url`,
+ *      which keeps the receipt's URL parseable by the regex in
+ *      `deploy.js::deriveLocalFoundationRef` even when the registry's index
+ *      entry doesn't carry an explicit `url` field. (Unicloud's index entries
+ *      don't; uniweb-edge's index entries don't either — both rely on the
+ *      response shape, not the index shape.)
+ *
+ * Path-shaped candidates (e.g. `/foundations/...`) are joined with the
+ * registry's `apiUrl` so the receipt always carries an absolute URL.
+ */
+export function deriveReceiptUrl({ publishResult, existingEntry, registry, name, version, isLocal }) {
+  const candidate = publishResult?.url || existingEntry?.url
+  if (candidate) {
+    if (candidate.startsWith('http') || candidate.startsWith('file://')) return candidate
+    if (registry?.apiUrl) return new URL(candidate, registry.apiUrl).toString()
+  }
+  if (isLocal) return `file://${registry.getPackagePath(name, version)}/`
+  return `${registry.apiUrl.replace(/\/$/, '')}/foundations/${name}@${version}/foundation.js`
+}
+
+/**
+ * Build a receipt from an existing registry version entry, used to refill a
+ * missing `dist/publish.json` from server-of-record state. Returns null if
+ * the entry doesn't carry enough provenance to make the receipt useful for
+ * staleness checks (the only field that strictly must be present is
+ * `publishedFromGitSha` — without it, the deploy verb can't compare against
+ * HEAD, and refilling would just re-trigger the auto-publish next run).
+ */
+export function receiptFromRegistryEntry({ existingEntry, registry, name, version, isLocal, isPropagateDefault }) {
+  if (!existingEntry || !existingEntry.publishedFromGitSha) return null
+  return composeReceipt({
+    gitSha: existingEntry.publishedFromGitSha,
+    gitDirty: existingEntry.publishedFromGitDirty ?? false,
+    url: deriveReceiptUrl({ existingEntry, registry, name, version, isLocal }),
+    publishedAt: existingEntry.publishedAt || new Date().toISOString(),
+    classification: existingEntry.classification || (isPropagateDefault ? 'propagate' : 'silent'),
+  })
+}
+
+/**
+ * Split `@ns/name@ver`, `~user/name@ver`, or `name@ver` into name + version.
+ * Returns null on any shape we don't recognize.
+ */
+export function splitRegistryRef(ref) {
+  if (typeof ref !== 'string') return null
+  const m = /^(@[^/]+\/[^@]+|~[^/]+\/[^@]+|[^@]+)@(.+)$/.exec(ref)
+  return m ? { name: m[1], version: m[2] } : null
+}

package/src/utils/registry.js

@@ -142,6 +142,21 @@ export class LocalRegistry {
     return index[name]?.versions || []
   }
 
+  /**
+   * Get the full version entry for `name@version`, or null if absent.
+   * Used by `publish` and `deploy` to refill `dist/publish.json` from
+   * server-of-record state when the local cache is missing — see
+   * `kb/framework/build/workspace-ergonomics.md` (receipt-as-cache).
+   *
+   * @param {string} name
+   * @param {string} version
+   * @returns {Promise<Object|null>}
+   */
+  async getVersionEntry(name, version) {
+    const versions = await this.getVersions(name)
+    return versions.find(v => v.version === version) || null
+  }
+
   /**
    * Publish a foundation to the local registry.
    * Copies the dist directory and updates the index.
@@ -253,6 +268,24 @@ export class RemoteRegistry {
     return index[name]?.versions || []
   }
 
+  /**
+   * Get the full version entry for `name@version`, or null if absent.
+   * Used by `publish` and `deploy` to refill `dist/publish.json` from
+   * server-of-record state when the local cache is missing.
+   *
+   * @param {string} name
+   * @param {string} version
+   * @returns {Promise<Object|null>}
+   */
+  async getVersionEntry(name, version) {
+    try {
+      const versions = await this.getVersions(name)
+      return versions.find(v => v.version === version) || null
+    } catch {
+      return null
+    }
+  }
+
   /**
    * Publish a foundation to the remote registry.
    * Reads files from distDir, encodes as base64, and POSTs to the server.

package/templates/workspace/package.json.hbs

@@ -8,13 +8,11 @@
     "{{@key}}": "{{this}}"{{#unless @last}},{{/unless}}
     {{/each}}
   },
-  {{#if workspaceGlobs.length}}
-  "workspaces": [
+  "workspaces": [{{#if workspaceGlobs.length}}
     {{#each workspaceGlobs}}
     "{{this}}"{{#unless @last}},{{/unless}}
     {{/each}}
-  ],
-  {{/if}}
+  {{/if}}],
   "devDependencies": {
     "@types/node": "^22.0.0",
     "uniweb": "{{version "uniweb"}}"