uniweb 0.12.14 → 0.12.16

package/src/utils/config.js

@@ -10,6 +10,7 @@ import { readFile, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 import yaml from 'js-yaml'
+import { classifyPackage } from '@uniweb/build'
 import { filterCmd } from './pm.js'
 
 // ── Platform URLs ──────────────────────────────────────────────
@@ -228,27 +229,7 @@ export async function updateRootScripts(rootDir, sites, pm = 'pnpm') {
  * @returns {Promise<Array<{name: string, path: string}>>}
  */
 export async function discoverFoundations(rootDir) {
-  const { packages } = await readWorkspaceConfig(rootDir)
-  const foundations = []
-
-  for (const pattern of packages) {
-    const dirs = await resolveGlob(rootDir, pattern)
-    for (const dir of dirs) {
-      const pkgPath = join(rootDir, dir, 'package.json')
-      if (!existsSync(pkgPath)) continue
-      try {
-        const pkg = JSON.parse(await readFile(pkgPath, 'utf-8'))
-        // Foundation: has @uniweb/build in devDeps but NOT @uniweb/runtime in deps
-        if (pkg.devDependencies?.['@uniweb/build'] && !pkg.dependencies?.['@uniweb/runtime']) {
-          foundations.push({ name: pkg.name, path: dir })
-        }
-      } catch {
-        // skip
-      }
-    }
-  }
-
-  return foundations
+  return discoverByKind(rootDir, 'foundation')
 }
 
 /**
@@ -257,27 +238,46 @@ export async function discoverFoundations(rootDir) {
  * @returns {Promise<Array<{name: string, path: string}>>}
  */
 export async function discoverSites(rootDir) {
+  return discoverByKind(rootDir, 'site')
+}
+
+/**
+ * Walk the workspace globs and return packages of the requested kind.
+ * Uses `classifyPackage` from @uniweb/build — the canonical classifier
+ * shared with the build pipeline, which keys on real signals (site.yml
+ * for sites, generated entry for foundations) rather than which
+ * `@uniweb/*` packages happen to be in dependencies. Templates whose
+ * sites pull runtime transitively through the foundation (e.g.,
+ * marketing) used to be invisible to the older dependency-based check.
+ */
+async function discoverByKind(rootDir, kind) {
   const { packages } = await readWorkspaceConfig(rootDir)
-  const sites = []
+  const out = []
 
   for (const pattern of packages) {
     const dirs = await resolveGlob(rootDir, pattern)
     for (const dir of dirs) {
-      const pkgPath = join(rootDir, dir, 'package.json')
-      if (!existsSync(pkgPath)) continue
-      try {
-        const pkg = JSON.parse(await readFile(pkgPath, 'utf-8'))
-        // Site: has @uniweb/runtime in deps
-        if (pkg.dependencies?.['@uniweb/runtime']) {
-          sites.push({ name: pkg.name, path: dir })
+      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
         }
-      } catch {
-        // skip
       }
+      out.push({ name, path: dir })
     }
   }
 
-  return sites
+  return out
 }
 
 // Resolve a workspace glob pattern to actual directories

package/src/utils/pm.js

@@ -5,9 +5,17 @@
  * and generate PM-appropriate commands for output messages.
  */
 
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+
 /**
  * Detect which package manager invoked the CLI.
  * Uses the standard npm_config_user_agent env var (same technique as create-vite, create-next-app).
+ *
+ * Note: this returns the *invoker* PM, which is empty when the user runs
+ * a global CLI binary directly from a shell. For the workspace's own PM
+ * (driven by lockfile presence), use `detectWorkspacePm`.
+ *
  * @returns {'pnpm' | 'npm'}
  */
 export function detectPackageManager() {
@@ -16,6 +24,22 @@ export function detectPackageManager() {
   return 'npm'
 }
 
+/**
+ * Detect the workspace's package manager by inspecting lockfiles at the
+ * workspace root. This is the right signal for "what PM should I use to
+ * install in this workspace" — independent of how the CLI was invoked.
+ *
+ * @param {string} workspaceRoot - Absolute path to workspace root
+ * @returns {'pnpm' | 'yarn' | 'npm' | null} - null when no lockfile is present
+ */
+export function detectWorkspacePm(workspaceRoot) {
+  if (!workspaceRoot) return null
+  if (existsSync(join(workspaceRoot, 'pnpm-lock.yaml'))) return 'pnpm'
+  if (existsSync(join(workspaceRoot, 'yarn.lock'))) return 'yarn'
+  if (existsSync(join(workspaceRoot, 'package-lock.json'))) return 'npm'
+  return null
+}
+
 /**
  * Generate a workspace-filtered command.
  * pnpm: "pnpm --filter site dev"
@@ -33,11 +57,13 @@ export function filterCmd(pm, pkg, cmd) {
 
 /**
  * Generate an install command.
- * @param {'pnpm' | 'npm'} pm
+ * @param {'pnpm' | 'yarn' | 'npm'} pm
  * @returns {string}
  */
 export function installCmd(pm) {
-  return pm === 'pnpm' ? 'pnpm install' : 'npm install'
+  if (pm === 'pnpm') return 'pnpm install'
+  if (pm === 'yarn') return 'yarn install'
+  return 'npm install'
 }
 
 /**