uniweb 0.12.20 → 0.12.22

package/src/templates/processor.js

@@ -166,6 +166,35 @@ async function processFile(sourcePath, targetPath, data, options = {}) {
   }
 }
 
+/**
+ * Rename a leading single underscore to a dot: `_gitignore` → `.gitignore`,
+ * `_vscode` → `.vscode`.
+ *
+ * Dotfiles live in the template source under a `_`-prefixed name for two
+ * reasons: (1) so they aren't swept up by the template repo's own git ignore
+ * rules, and (2) — critically — so they survive `npm publish`. npm strips any
+ * file literally named `.gitignore` from the package tarball (it's treated as
+ * an ignore-source, not shippable content), so a template that needs to ship a
+ * `.gitignore` MUST store it as `_gitignore` and rename it at scaffold time.
+ * `.gitkeep` and other dotfiles ship fine; `.gitignore` is the trap.
+ *
+ * `__name` (double underscore) is left untouched, matching the prior
+ * directory-only behavior.
+ */
+function dotfileRename(name) {
+  return name.startsWith('_') && !name.startsWith('__') ? `.${name.slice(1)}` : name
+}
+
+/**
+ * Compute a template file's scaffolded output name: strip the `.hbs`
+ * Handlebars suffix, then apply {@link dotfileRename}. So `_gitignore` →
+ * `.gitignore` and `_env.local.hbs` → `.env.local`.
+ */
+function templateOutputName(sourceName) {
+  const base = sourceName.endsWith('.hbs') ? sourceName.slice(0, -4) : sourceName
+  return dotfileRename(base)
+}
+
 /**
  * Copy a directory structure recursively, processing templates
  *
@@ -187,12 +216,8 @@ export async function copyTemplateDirectory(sourcePath, targetPath, data, option
 
     if (entry.isDirectory()) {
       const sourceFullPath = path.join(sourcePath, sourceName)
-      // Rename _prefix directories to .prefix (e.g., _vscode → .vscode)
-      // This allows dotfile directories to be committed without being gitignored
-      const targetName = sourceName.startsWith('_') && !sourceName.startsWith('__')
-        ? `.${sourceName.slice(1)}`
-        : sourceName
-      const targetFullPath = path.join(targetPath, targetName)
+      // Rename _prefix directories to .prefix (e.g., _vscode → .vscode).
+      const targetFullPath = path.join(targetPath, dotfileRename(sourceName))
 
       await copyTemplateDirectory(sourceFullPath, targetFullPath, data, { onWarning, onProgress, skip })
     } else {
@@ -201,17 +226,14 @@ export async function copyTemplateDirectory(sourcePath, targetPath, data, option
         continue
       }
 
-      // Determine the output filename (strip .hbs extension) for skip check
-      const outputName = sourceName.endsWith('.hbs') ? sourceName.slice(0, -4) : sourceName
-      if (skip?.includes(outputName)) {
+      // Output name: strip `.hbs`, then rename a leading `_` to `.`
+      // (e.g. `_gitignore` → `.gitignore`). Used for both the skip check and
+      // the written filename so they can't drift.
+      const targetName = templateOutputName(sourceName)
+      if (skip?.includes(targetName)) {
         continue
       }
 
-      // Remove .hbs extension for target filename
-      const targetName = sourceName.endsWith('.hbs')
-        ? sourceName.slice(0, -4)
-        : sourceName
-
       const sourceFullPath = path.join(sourcePath, sourceName)
       const targetFullPath = path.join(targetPath, targetName)
 
@@ -228,7 +250,9 @@ export async function copyTemplateDirectory(sourcePath, targetPath, data, option
  * Enumerate the output paths a template directory would write, without
  * touching disk. Mirrors `copyTemplateDirectory`'s naming rules:
  *   - `.hbs` extension is stripped
- *   - `_dir` is renamed to `.dir` (but `__dir` is preserved as `_dir` would be)
+ *   - a leading `_` is renamed to `.` for both files and directories
+ *     (e.g. `_gitignore` → `.gitignore`, `_vscode` → `.vscode`); `__name`
+ *     is preserved
  *   - `template.json` is excluded
  *   - `skip` filenames are excluded by their post-rename name
  *
@@ -253,9 +277,7 @@ async function enumerateInto(sourcePath, relPath, outputs, skip) {
   for (const entry of entries) {
     const sourceName = entry.name
     if (entry.isDirectory()) {
-      const targetName = sourceName.startsWith('_') && !sourceName.startsWith('__')
-        ? `.${sourceName.slice(1)}`
-        : sourceName
+      const targetName = dotfileRename(sourceName)
       await enumerateInto(
         path.join(sourcePath, sourceName),
         relPath ? path.join(relPath, targetName) : targetName,
@@ -264,7 +286,7 @@ async function enumerateInto(sourcePath, relPath, outputs, skip) {
       )
     } else {
       if (sourceName === 'template.json') continue
-      const outputName = sourceName.endsWith('.hbs') ? sourceName.slice(0, -4) : sourceName
+      const outputName = templateOutputName(sourceName)
       if (skip.includes(outputName)) continue
       outputs.push(relPath ? path.join(relPath, outputName) : outputName)
     }

package/src/utils/config.js

@@ -20,6 +20,7 @@ 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'
 
 // ── Platform URLs ──────────────────────────────────────────────
 
@@ -82,6 +83,27 @@ export function getRegistryUrl() {
     || PRODUCTION_REGISTRY_URL
 }
 
+/**
+ * Get the new registry backend's API base origin — DISTINCT from the
+ * legacy PHP getBackendUrl(). `register` POSTs to {origin}/dev/registry/register
+ * and the new-backend `login` to {origin}/dev/auth/login.
+ *
+ * Priority: UNIWEB_REGISTER_URL's origin (the env users already set for
+ * register) > ~/.uniweb/config.json registryApiUrl > local default.
+ * @returns {string}
+ */
+export function getRegistryApiBaseUrl() {
+  const fromEnv = process.env.UNIWEB_REGISTER_URL
+  if (fromEnv) {
+    try { return new URL(fromEnv).origin } catch { /* fall through */ }
+  }
+  const fromCfg = readCliConfig().registryApiUrl
+  if (fromCfg) {
+    try { return new URL(fromCfg).origin } catch { return fromCfg }
+  }
+  return 'http://localhost:8080'
+}
+
 /**
  * Read workspace package globs.
  * Tries pnpm-workspace.yaml first, falls back to package.json workspaces.
@@ -154,13 +176,19 @@ export async function readRootPackageJson(rootDir) {
 }
 
 /**
- * Write root package.json (2-space indent)
+ * Write root package.json, preserving the file's existing indentation
+ * (newly scaffolded workspaces use 2-space; we don't reflow whatever's
+ * already there).
  * @param {string} rootDir - Workspace root directory
  * @param {Object} pkg - Package.json object
  */
 export async function writeRootPackageJson(rootDir, pkg) {
   const pkgPath = join(rootDir, 'package.json')
-  await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
+  if (existsSync(pkgPath)) {
+    await writeJsonPreservingStyleAsync(pkgPath, pkg)
+  } else {
+    await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
+  }
 }
 
 /**

package/src/utils/dep-survey.js

@@ -0,0 +1,99 @@
+/**
+ * Workspace `@uniweb/*` dependency survey.
+ *
+ * Compares the `@uniweb/*` + `uniweb` versions *declared* in every
+ * package.json across a workspace against the running CLI's bundled
+ * version matrix (`getResolvedVersions`). Shared by `uniweb update`
+ * (which fixes the drift) and `uniweb doctor` (which only reports it) so
+ * the two never disagree about what "out of date" means.
+ *
+ * Comparison is on declared specs, not installed (node_modules) versions
+ * — that's what's committed and what `git diff` will show after a fix.
+ */
+
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { getResolvedVersions } from '../versions.js'
+import { getWorkspacePackages } from './workspace.js'
+
+/**
+ * Strip a leading semver range operator (^, ~, >=, <, …) so two specs can
+ * be compared by their underlying version. Range expressions like
+ * ">=0.5 <0.7" aren't fully parsed — the first version-shaped token wins.
+ * Sufficient for `@uniweb/*` deps, which use `^x.y.z` / `x.y.z`.
+ * @param {string} spec
+ * @returns {string}
+ */
+export function stripVersionRange(spec) {
+  return (spec || '').replace(/^[\^~>=<\s]+/, '').trim().split(/\s+/)[0] || ''
+}
+
+/**
+ * Compare two version specs (range prefix tolerated). Returns 1 / -1 / 0.
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+export function compareSemver(a, b) {
+  const pa = stripVersionRange(a).split('.').map(Number)
+  const pb = stripVersionRange(b).split('.').map(Number)
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1
+  }
+  return 0
+}
+
+/**
+ * @typedef {object} DepRow
+ * @property {string} relDir   Workspace-relative dir, or '(root)'.
+ * @property {string} section  'dependencies' | 'devDependencies' | 'peerDependencies'
+ * @property {string} name     Package name (e.g. '@uniweb/core' or 'uniweb').
+ * @property {string} current  The spec declared in package.json.
+ * @property {string} target   The spec the running CLI's matrix wants.
+ * @property {'aligned'|'behind'|'ahead'} status  current vs target.
+ */
+
+/**
+ * Survey a workspace's declared `@uniweb/*` + `uniweb` deps against the
+ * running CLI's bundled matrix.
+ *
+ * @param {string} workspaceDir Absolute path to the workspace root.
+ * @returns {Promise<{ targets: Record<string,string>, rows: DepRow[], anyDrift: boolean, anyAhead: boolean }>}
+ *   `anyDrift` — at least one dep lags the matrix. `anyAhead` — at least
+ *   one dep is newer than the matrix.
+ */
+export async function surveyWorkspaceDeps(workspaceDir) {
+  const targets = getResolvedVersions()
+  const packages = await getWorkspacePackages(workspaceDir)
+  const dirs = ['', ...packages]
+  const rows = []
+  let anyDrift = false
+  let anyAhead = false
+
+  for (const relDir of dirs) {
+    const pkgDir = relDir ? join(workspaceDir, relDir) : workspaceDir
+    const pkgPath = join(pkgDir, 'package.json')
+    if (!existsSync(pkgPath)) continue
+    let pkg
+    try { pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) } catch { continue }
+
+    for (const sectionName of ['dependencies', 'devDependencies', 'peerDependencies']) {
+      const section = pkg[sectionName]
+      if (!section) continue
+      for (const [name, current] of Object.entries(section)) {
+        if (!(name.startsWith('@uniweb/') || name === 'uniweb')) continue
+        const target = targets[name]
+        if (!target) continue
+        const cmp = compareSemver(target, current)
+        let status
+        if (cmp > 0) { status = 'behind'; anyDrift = true }
+        else if (cmp < 0) { status = 'ahead'; anyAhead = true }
+        else { status = 'aligned' }
+        rows.push({ relDir: relDir || '(root)', section: sectionName, name, current, target, status })
+      }
+    }
+  }
+
+  return { targets, rows, anyDrift, anyAhead }
+}

package/src/utils/json-file.js

@@ -0,0 +1,68 @@
+/**
+ * Style-preserving JSON file writes.
+ *
+ * The CLI rewrites `package.json` in several places (`update`, `doctor`,
+ * `rename`, `add`). A naive `JSON.stringify(obj, null, 2)` reflows the
+ * *entire* file whenever the project happened to use tabs or 4-space
+ * indentation — turning a one-key version bump into a hundred-line diff
+ * (and a needless merge-conflict surface). `framework/CLAUDE.md` calls
+ * this out as an anti-pattern for human commits; the tooling shouldn't do
+ * it either. These helpers detect the file's existing indentation and
+ * trailing-newline convention and preserve both.
+ */
+
+import { readFileSync, writeFileSync } from 'node:fs'
+import { readFile, writeFile } from 'node:fs/promises'
+
+/**
+ * Detect the indentation unit a JSON source string uses.
+ * @param {string} src
+ * @returns {number|string} A space count, or '\t' for tab-indented files.
+ *   Defaults to 2 when the file has no indented lines (e.g. `{}`).
+ */
+export function detectJsonIndent(src) {
+  const m = src.match(/\n([ \t]+)\S/)
+  if (!m) return 2
+  const lead = m[1]
+  if (lead.includes('\t')) return '\t'
+  return lead.length
+}
+
+/**
+ * Serialize `obj` to JSON using the indentation and trailing-newline
+ * convention of `originalSrc` (or of the file currently at `filePath`).
+ * @param {object} obj
+ * @param {string} originalSrc - The file's current text.
+ * @returns {string}
+ */
+export function stringifyJsonLike(obj, originalSrc) {
+  const indent = detectJsonIndent(originalSrc)
+  const body = JSON.stringify(obj, null, indent)
+  return originalSrc.endsWith('\n') ? body + '\n' : body
+}
+
+/**
+ * Write `obj` to `filePath` as JSON, preserving the file's existing
+ * indentation and trailing-newline convention. Pass `originalSrc` when
+ * the caller already has the file contents in hand (avoids a re-read);
+ * otherwise the file is read to sniff its style.
+ * @param {string} filePath
+ * @param {object} obj
+ * @param {string|null} [originalSrc]
+ */
+export function writeJsonPreservingStyle(filePath, obj, originalSrc = null) {
+  const src = originalSrc ?? readFileSync(filePath, 'utf8')
+  writeFileSync(filePath, stringifyJsonLike(obj, src))
+}
+
+/**
+ * Async counterpart to {@link writeJsonPreservingStyle}, for the CLI's
+ * many `node:fs/promises`-based call sites.
+ * @param {string} filePath
+ * @param {object} obj
+ * @param {string|null} [originalSrc]
+ */
+export async function writeJsonPreservingStyleAsync(filePath, obj, originalSrc = null) {
+  const src = originalSrc ?? await readFile(filePath, 'utf8')
+  await writeFile(filePath, stringifyJsonLike(obj, src))
+}

package/src/utils/placement.js

@@ -0,0 +1,100 @@
+/**
+ * Package placement resolution — shared by `add` and `clone`.
+ *
+ * Kept dependency-free (no `@uniweb/build`, no fs) on purpose: `clone` imports
+ * it and must run from a global install before any project — anything that
+ * statically pulls in `@uniweb/build` would crash `npx uniweb@latest clone`
+ * (the same reason `utils/workspace.js` loads the classifier lazily).
+ */
+
+/** Foundation placement defaults (folder `src/`, package `src`). */
+export const FOUNDATION_KIND = { defaultDir: 'src', defaultPkg: 'src', projectSub: 'src' }
+
+/** Site placement defaults (folder `site/`, package `site`). */
+export const SITE_KIND = { defaultDir: 'site', defaultPkg: 'site', projectSub: 'site' }
+
+/**
+ * Resolve where a foundation or site should be placed, given the user's input.
+ *
+ * The rule: **the user names a folder, and we create exactly that folder.**
+ * No silent nesting under `foundations/` / `sites/`, no inferring layout from
+ * pre-existing globs. The framework doesn't require any particular folder
+ * structure (the build classifies packages by their contents, not their
+ * location), so the CLI shouldn't impose one.
+ *
+ * Resolution priority (foundation example, same shape for site):
+ *
+ *   1. `--path <dir>`                   → explicit folder. Name is the path's
+ *                                          last segment (used as the package
+ *                                          name unless `name` was also given).
+ *   2. `name` contains `/`              → treat as a path (e.g., `foundations/ui`).
+ *                                          Folder = the path, package name =
+ *                                          the last segment.
+ *   3. `name` (no slash)                → folder = `<name>/`, package name = `<name>`.
+ *   4. `--project <project>`            → folder = `<project>/<defaultSub>` and
+ *                                          package name = `<project>-<defaultSub>`
+ *                                          (the co-located convention; only this
+ *                                          one uses the `-src` / `-site` suffix).
+ *   5. (no input)                       → folder = `<defaultDir>/`, package name
+ *                                          = `<defaultPkg>` (`src/` + `src`
+ *                                          for foundations; `site/` + `site` for
+ *                                          sites).
+ *
+ * @param {string} rootDir
+ * @param {string|null} name - Either a bare name or a path-with-slash.
+ * @param {{ path?: string, project?: string }} opts
+ * @param {{ defaultDir: string, defaultPkg: string, projectSub: string }} kind
+ * @returns {{ relativePath: string, packageName: string }}
+ */
+export function resolvePlacement(rootDir, name, opts, kind) {
+  // 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).
+  if (opts.path) {
+    const parent = opts.path.replace(/\/+$/, '')
+    if (name) {
+      const last = name.split('/').filter(Boolean).pop()
+      return {
+        relativePath: `${parent}/${name}`.replace(/\/+/g, '/'),
+        packageName: last,
+      }
+    }
+    const lastSegment = parent.split('/').filter(Boolean).pop() || parent
+    return {
+      relativePath: parent,
+      packageName: lastSegment,
+    }
+  }
+
+  // 2. name contains a slash → treat as a path.
+  if (name && name.includes('/')) {
+    const relativePath = name.replace(/\/+$/, '')
+    const lastSegment = relativePath.split('/').filter(Boolean).pop()
+    return {
+      relativePath,
+      packageName: lastSegment,
+    }
+  }
+
+  // 3. Bare name.
+  if (name) {
+    return {
+      relativePath: name,
+      packageName: name,
+    }
+  }
+
+  // 4. --project (co-located convention with -src / -site suffix).
+  if (opts.project) {
+    return {
+      relativePath: `${opts.project}/${kind.projectSub}`,
+      packageName: `${opts.project}-${kind.projectSub}`,
+    }
+  }
+
+  // 5. Default placement.
+  return {
+    relativePath: kind.defaultDir,
+    packageName: kind.defaultPkg,
+  }
+}

package/src/utils/pm.js

@@ -40,6 +40,35 @@ export function detectWorkspacePm(workspaceRoot) {
   return null
 }
 
+/**
+ * Detect which package manager owns a *globally installed* `uniweb` CLI
+ * binary, by inspecting its install path (`process.argv[1]`). pnpm and
+ * yarn keep global packages under recognizable directory segments;
+ * everything else is assumed to be npm. Only meaningful when the CLI is
+ * actually a global install (see index.js::isGlobalInstall) — a
+ * project-local or npx-launched copy is updated differently.
+ *
+ * @returns {'pnpm' | 'yarn' | 'npm'}
+ */
+export function detectGlobalCliPm() {
+  const path = (process.argv[1] || '').toLowerCase().replace(/\\/g, '/')
+  if (path.includes('/pnpm/')) return 'pnpm'
+  if (path.includes('/yarn/')) return 'yarn'
+  return 'npm'
+}
+
+/**
+ * The command to (re)install the latest `uniweb` CLI globally with a
+ * given package manager.
+ * @param {'pnpm' | 'yarn' | 'npm'} pm
+ * @returns {string}
+ */
+export function globalCliUpdateCmd(pm) {
+  if (pm === 'pnpm') return 'pnpm add -g uniweb@latest'
+  if (pm === 'yarn') return 'yarn global add uniweb@latest'
+  return 'npm i -g uniweb@latest'
+}
+
 /**
  * Generate a workspace-filtered command.
  * pnpm: "pnpm --filter site dev"