uniweb 0.12.2 → 0.12.4

package/src/commands/doctor.js

@@ -2,12 +2,30 @@
  * uniweb doctor - Diagnose project configuration issues
  */
 
-import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import { existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
 import { join, resolve, basename, dirname, relative } from 'node:path'
 import yaml from 'js-yaml'
 import { resolveFoundationSrcPath, classifyPackage, isExtensionPackage as buildIsExtensionPackage } from '@uniweb/build'
 import { getCliVersion } from '../versions.js'
 import { readAgentsVersion } from '../utils/agents-stamp.js'
+import { discoverFoundations, discoverSites } from '../utils/config.js'
+import { findWorkspaceRoot } from '../utils/workspace.js'
+
+/**
+ * Parse the `--fix [<issue-id>]` flag.
+ *
+ * Returns:
+ *   null         — no auto-fix requested.
+ *   'all'        — fix every auto-fixable issue.
+ *   '<issue-id>' — fix only issues with this id.
+ */
+function parseFixFlag(args) {
+  const idx = args.indexOf('--fix')
+  if (idx === -1) return null
+  const next = args[idx + 1]
+  if (!next || next.startsWith('--')) return 'all'
+  return next
+}
 
 // ANSI colors
 const colors = {
@@ -119,29 +137,20 @@ export async function doctor(args = []) {
   log(`${colors.blue}${colors.bright}Uniweb Doctor${colors.reset}`)
   log(`${colors.dim}Checking project configuration...${colors.reset}`)
 
-  const projectDir = resolve(process.cwd())
-
-  // Detect project type and find workspace root
-  let workspaceDir = projectDir
+  // Auto-fix mode. `--fix` alone fixes every recoverable issue;
+  // `--fix <issue-id>` targets one. Per-issue fix logic lives next to
+  // each diagnostic below so the rewrite happens with full context.
+  const fixFlag = parseFixFlag(args)
+  const shouldFix = (id) => fixFlag === 'all' || fixFlag === id
+  const fixed = (msg) => console.log(`  ${colors.green}↳ Fixed:${colors.reset} ${msg}`)
 
-  if (isSite(projectDir)) {
-    workspaceDir = dirname(projectDir)
-    if (basename(workspaceDir) === 'sites') {
-      workspaceDir = dirname(workspaceDir)
-    }
-  } else if (isFoundation(projectDir)) {
-    workspaceDir = dirname(projectDir)
-    const parentName = basename(workspaceDir)
-    if (parentName === 'foundations' || parentName === 'extensions') {
-      workspaceDir = dirname(workspaceDir)
-    }
-  }
+  const projectDir = resolve(process.cwd())
 
-  // Check workspace structure
-  const hasWorkspaceConfig = existsSync(join(workspaceDir, 'pnpm-workspace.yaml')) ||
-                             existsSync(join(workspaceDir, 'package.json'))
+  // Find workspace root via the canonical primitive (recognizes
+  // pnpm-workspace.yaml or package.json::workspaces).
+  const workspaceDir = findWorkspaceRoot(projectDir)
 
-  if (!hasWorkspaceConfig) {
+  if (!workspaceDir) {
     error('Not in a Uniweb workspace')
     log(`${colors.dim}Run this command from your project root or a site/foundation directory.${colors.reset}`)
     process.exit(1)
@@ -150,65 +159,76 @@ export async function doctor(args = []) {
   log('')
   info(`Workspace: ${workspaceDir}`)
 
-  // Find all foundations
-  const foundations = []
-
-  // Check single-foundation layout
-  const foundationDir = join(workspaceDir, 'foundation')
-  if (isFoundation(foundationDir)) {
-    const pkg = loadPackageJson(foundationDir)
-    foundations.push({
-      path: foundationDir,
-      name: pkg?.name || 'foundation',
-      folderName: 'foundation'
-    })
-  }
-
-  // Check multi-foundation layout
-  const foundationsDir = join(workspaceDir, 'foundations')
-  if (existsSync(foundationsDir)) {
+  // Workspace manifest sync — keep `pnpm-workspace.yaml::packages` and
+  // `package.json::workspaces` aligned. The CLI writes both on every
+  // mutation (see addWorkspaceGlob in utils/config.js), but a user who
+  // manually edits one can introduce drift. Drift breaks projects that
+  // switch package managers (pnpm-workspace.yaml is pnpm-only;
+  // package.json::workspaces is what npm and yarn read).
+  const issues = []
+  const ymlPath = join(workspaceDir, 'pnpm-workspace.yaml')
+  if (existsSync(ymlPath)) {
+    let ymlPackages = []
     try {
-      const entries = readdirSync(foundationsDir, { withFileTypes: true })
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          const foundationPath = join(foundationsDir, entry.name)
-          if (isFoundation(foundationPath)) {
-            const pkg = loadPackageJson(foundationPath)
-            foundations.push({
-              path: foundationPath,
-              name: pkg?.name || entry.name,
-              folderName: entry.name
-            })
-          }
-        }
-      }
+      ymlPackages = yaml.load(readFileSync(ymlPath, 'utf8'))?.packages || []
     } catch {
-      // Ignore errors
+      // Malformed yaml — flag separately
+      issues.push({
+        id: 'workspace-yaml-malformed',
+        type: 'error',
+        message: 'pnpm-workspace.yaml is malformed and could not be parsed.',
+      })
+      error('pnpm-workspace.yaml is malformed and could not be parsed.')
+    }
+    const rootPkg = loadPackageJson(workspaceDir)
+    const pkgWorkspaces = Array.isArray(rootPkg?.workspaces) ? rootPkg.workspaces : []
+    const ymlSet = new Set(ymlPackages)
+    const pkgSet = new Set(pkgWorkspaces)
+    const onlyInYml = [...ymlSet].filter(g => !pkgSet.has(g))
+    const onlyInPkg = [...pkgSet].filter(g => !ymlSet.has(g))
+    if (onlyInYml.length || onlyInPkg.length) {
+      const issue = {
+        id: 'workspace-manifests-out-of-sync',
+        type: 'warn',
+        message: `pnpm-workspace.yaml and package.json::workspaces declare different package globs.`,
+        details: { onlyInYml, onlyInPkg },
+      }
+      issues.push(issue)
+      warn(`[workspace-manifests-out-of-sync] pnpm-workspace.yaml and package.json::workspaces are out of sync:`)
+      if (onlyInYml.length) log(`    only in pnpm-workspace.yaml:        ${onlyInYml.join(', ')}`)
+      if (onlyInPkg.length) log(`    only in package.json::workspaces:    ${onlyInPkg.join(', ')}`)
+      if (shouldFix('workspace-manifests-out-of-sync')) {
+        // Canonical resolution: write the union to both manifests.
+        const union = Array.from(new Set([...ymlPackages, ...pkgWorkspaces])).sort()
+        writeFileSync(ymlPath, yaml.dump({ packages: union }, { flowLevel: -1, quotingType: '"' }))
+        const rootPkgPath = join(workspaceDir, 'package.json')
+        const rootPkg = JSON.parse(readFileSync(rootPkgPath, 'utf-8'))
+        rootPkg.workspaces = union
+        writeFileSync(rootPkgPath, JSON.stringify(rootPkg, null, 2) + '\n')
+        issue.fixed = true
+        fixed(`wrote union [${union.join(', ')}] to both manifests`)
+      } else {
+        log(`  ${colors.dim}Pick one set of globs and copy it to the other manifest. The two should always match — pnpm reads pnpm-workspace.yaml, npm/yarn read package.json::workspaces.${colors.reset}`)
+      }
     }
   }
 
-  // Discover extensions
+  // Discover foundations + sites via the canonical workspace globs.
+  // Doctor used to walk fixed paths (`foundation/`, `foundations/*`) which
+  // missed the default-path `src/` shape that Thread D made canonical.
+  // Using the same primitives every other command uses keeps doctor in
+  // step with whatever layout the workspace has.
+  const discovered = await discoverFoundations(workspaceDir)
+  const foundations = []
   const extensions = []
-
-  const extensionsDir = join(workspaceDir, 'extensions')
-  if (existsSync(extensionsDir)) {
-    try {
-      const entries = readdirSync(extensionsDir, { withFileTypes: true })
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          const extensionPath = join(extensionsDir, entry.name)
-          if (isFoundation(extensionPath)) {
-            const pkg = loadPackageJson(extensionPath)
-            extensions.push({
-              path: extensionPath,
-              name: pkg?.name || entry.name,
-              folderName: entry.name
-            })
-          }
-        }
-      }
-    } catch {
-      // Ignore errors
+  for (const f of discovered) {
+    const fullPath = join(workspaceDir, f.path)
+    const folderName = basename(f.path)
+    const entry = { path: fullPath, name: f.name, folderName }
+    if (buildIsExtensionPackage(fullPath)) {
+      extensions.push(entry)
+    } else {
+      foundations.push(entry)
     }
   }
 
@@ -231,32 +251,12 @@ export async function doctor(args = []) {
     }
   }
 
-  // Find all sites
-  const sites = []
-
-  // Check single-site layout
-  const siteDir = join(workspaceDir, 'site')
-  if (isSite(siteDir)) {
-    sites.push({ path: siteDir, name: 'site' })
-  }
-
-  // Check multi-site layout
-  const sitesDir = join(workspaceDir, 'sites')
-  if (existsSync(sitesDir)) {
-    try {
-      const entries = readdirSync(sitesDir, { withFileTypes: true })
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          const sitePath = join(sitesDir, entry.name)
-          if (isSite(sitePath)) {
-            sites.push({ path: sitePath, name: entry.name })
-          }
-        }
-      }
-    } catch {
-      // Ignore errors
-    }
-  }
+  // Discover sites via the canonical workspace globs (same rationale as
+  // foundations above: respects whatever layout the user chose).
+  const sites = (await discoverSites(workspaceDir)).map(s => ({
+    path: join(workspaceDir, s.path),
+    name: s.name,
+  }))
 
   if (sites.length === 0) {
     warn('No sites found')
@@ -268,9 +268,8 @@ export async function doctor(args = []) {
     }
   }
 
-  // Check each site
-  const issues = []
-
+  // Check each site (issues array was declared earlier alongside the
+  // workspace-manifest-sync check).
   for (const site of sites) {
     const siteName = site.name
     const sitePath = site.path
@@ -305,17 +304,27 @@ export async function doctor(args = []) {
       // Check if it might match a folder name instead
       const folderMatch = foundations.find(f => f.folderName === foundationName)
       if (folderMatch) {
-        issues.push({
+        const issue = {
+          id: 'foundation-name-mismatch',
           type: 'error',
           site: siteName,
-          message: `Foundation mismatch: site.yml uses folder name "${foundationName}" instead of package name "${folderMatch.name}"`
-        })
-        error(`Foundation mismatch:`)
+          message: `Foundation mismatch: site.yml uses folder name "${foundationName}" instead of package name "${folderMatch.name}"`,
+        }
+        issues.push(issue)
+        error(`[foundation-name-mismatch] Foundation mismatch:`)
         log(`    site.yml says: ${colors.yellow}foundation: ${foundationName}${colors.reset}`)
         log(`    This matches the folder name, but the package name is: ${colors.green}${folderMatch.name}${colors.reset}`)
-        log('')
-        log(`  ${colors.dim}To fix, update site.yml:${colors.reset}`)
-        log(`    foundation: ${folderMatch.name}`)
+        if (shouldFix('foundation-name-mismatch')) {
+          const siteYmlPath = join(sitePath, 'site.yml')
+          const updated = { ...siteYml, foundation: folderMatch.name }
+          writeFileSync(siteYmlPath, yaml.dump(updated, { flowLevel: -1, quotingType: "'" }))
+          issue.fixed = true
+          fixed(`${relative(workspaceDir, siteYmlPath)} now references "${folderMatch.name}"`)
+        } else {
+          log('')
+          log(`  ${colors.dim}To fix, update site.yml:${colors.reset}`)
+          log(`    foundation: ${folderMatch.name}`)
+        }
         continue
       }
 
@@ -340,30 +349,54 @@ export async function doctor(args = []) {
     const depValue = deps[foundationName]
 
     if (!depValue) {
-      issues.push({
+      const issue = {
+        id: 'missing-foundation-dep',
         type: 'error',
         site: siteName,
-        message: `Missing dependency "${foundationName}" in package.json`
-      })
-      error(`Missing dependency "${foundationName}" in package.json`)
-      log('')
-      log(`  ${colors.dim}Add to site's package.json dependencies:${colors.reset}`)
-      log(`    "${foundationName}": "file:${relative(sitePath, matchingFoundation.path)}"`)
+        message: `Missing dependency "${foundationName}" in package.json`,
+      }
+      issues.push(issue)
+      error(`[missing-foundation-dep] Missing dependency "${foundationName}" in package.json`)
+      const expectedPath = `file:${relative(sitePath, matchingFoundation.path)}`
+      if (shouldFix('missing-foundation-dep')) {
+        const sitePkgPath = join(sitePath, 'package.json')
+        const updatedPkg = { ...sitePkg }
+        updatedPkg.dependencies = { ...(updatedPkg.dependencies || {}), [foundationName]: expectedPath }
+        writeFileSync(sitePkgPath, JSON.stringify(updatedPkg, null, 2) + '\n')
+        issue.fixed = true
+        fixed(`added "${foundationName}": "${expectedPath}" to ${relative(workspaceDir, sitePkgPath)}`)
+      } else {
+        log('')
+        log(`  ${colors.dim}Add to site's package.json dependencies:${colors.reset}`)
+        log(`    "${foundationName}": "${expectedPath}"`)
+      }
       continue
     }
 
     if (depValue.startsWith('file:')) {
       const depPath = join(sitePath, depValue.slice(5))
       if (!existsSync(depPath)) {
-        issues.push({
+        const issue = {
+          id: 'stale-file-path',
           type: 'error',
           site: siteName,
-          message: `Dependency path doesn't exist: ${depValue}`
-        })
-        error(`Dependency path doesn't exist: ${depValue}`)
-        log('')
-        log(`  ${colors.dim}Update site's package.json:${colors.reset}`)
-        log(`    "${foundationName}": "file:${relative(sitePath, matchingFoundation.path)}"`)
+          message: `Dependency path doesn't exist: ${depValue}`,
+        }
+        issues.push(issue)
+        error(`[stale-file-path] Dependency path doesn't exist: ${depValue}`)
+        const expectedPath = `file:${relative(sitePath, matchingFoundation.path)}`
+        if (shouldFix('stale-file-path')) {
+          const sitePkgPath = join(sitePath, 'package.json')
+          const updatedPkg = { ...sitePkg }
+          updatedPkg.dependencies = { ...(updatedPkg.dependencies || {}), [foundationName]: expectedPath }
+          writeFileSync(sitePkgPath, JSON.stringify(updatedPkg, null, 2) + '\n')
+          issue.fixed = true
+          fixed(`updated "${foundationName}" to "${expectedPath}" in ${relative(workspaceDir, sitePkgPath)}`)
+        } else {
+          log('')
+          log(`  ${colors.dim}Update site's package.json:${colors.reset}`)
+          log(`    "${foundationName}": "${expectedPath}"`)
+        }
         continue
       }
       success(`Dependency path: ${depValue}`)
@@ -512,23 +545,32 @@ export async function doctor(args = []) {
   log('')
   log('─'.repeat(50))
 
-  const errors = issues.filter(i => i.type === 'error')
-  const warnings = issues.filter(i => i.type === 'warn')
+  // Fixed issues no longer count toward errors/warnings — they're
+  // resolved during this run. Exit code is based on what remains.
+  const errors = issues.filter(i => i.type === 'error' && !i.fixed)
+  const warnings = issues.filter(i => i.type === 'warn' && !i.fixed)
+  const fixedCount = issues.filter(i => i.fixed).length
 
-  if (errors.length === 0 && warnings.length === 0) {
+  if (errors.length === 0 && warnings.length === 0 && fixedCount === 0) {
     log('')
     log(`${colors.green}${colors.bright}All checks passed!${colors.reset}`)
     log('')
   } else {
     log('')
+    if (fixedCount > 0) {
+      log(`${colors.green}${fixedCount} issue(s) fixed${colors.reset}`)
+    }
     if (errors.length > 0) {
-      log(`${colors.red}${errors.length} error(s)${colors.reset}`)
+      log(`${colors.red}${errors.length} error(s) remaining${colors.reset}`)
     }
     if (warnings.length > 0) {
-      log(`${colors.yellow}${warnings.length} warning(s)${colors.reset}`)
+      log(`${colors.yellow}${warnings.length} warning(s) remaining${colors.reset}`)
+    }
+    if (fixFlag && (errors.length > 0 || warnings.length > 0)) {
+      log(`${colors.dim}Some issues were not auto-fixable. See the diagnostics above.${colors.reset}`)
     }
     log('')
   }
 
-  return { issues, errors: errors.length, warnings: warnings.length }
+  return { issues, errors: errors.length, warnings: warnings.length, fixed: fixedCount }
 }

package/src/commands/handoff.js

@@ -160,7 +160,7 @@ function showWebHandoff(email, name) {
   console.log('')
   info(`Web-based handoff`)
   console.log('')
-  console.log(`  1. Create a site on ${colors.cyan}hub.uniweb.app${colors.reset} using ${colors.bright}${name}${colors.reset}`)
+  console.log(`  1. Create a site on ${colors.cyan}uniweb.app${colors.reset} using ${colors.bright}${name}${colors.reset}`)
   console.log(`  2. Add pages and content`)
   console.log(`  3. Transfer ownership to ${colors.bright}${email}${colors.reset}:`)
   console.log(`     ${colors.dim}Settings → Transfer site${colors.reset}`)

package/src/commands/invite.js

@@ -275,10 +275,10 @@ async function handleCreate(args, email) {
     console.log('')
     if (isExtension) {
       console.log(`  ${colors.dim}When ${invite.email} adds ${name} to their site${colors.reset}`)
-      console.log(`  ${colors.dim}on hub.uniweb.app or Studio, it will be authorized automatically.${colors.reset}`)
+      console.log(`  ${colors.dim}on uniweb.app or Studio, it will be authorized automatically.${colors.reset}`)
     } else {
       console.log(`  ${colors.dim}When ${invite.email} creates a site with ${name}${colors.reset}`)
-      console.log(`  ${colors.dim}on hub.uniweb.app or Studio, it will be authorized automatically.${colors.reset}`)
+      console.log(`  ${colors.dim}on uniweb.app or Studio, it will be authorized automatically.${colors.reset}`)
     }
   } catch (err) {
     error(err.message)