uniweb 0.12.16 → 0.12.18

package/README.md

@@ -40,12 +40,18 @@ Edit files in `site/pages/` and `src/sections/` to see changes instantly.
 
 Use `--blank` for an empty workspace (no packages) — grow with `uniweb add`.
 
-Or skip the interactive prompt:
+**Two starting points.** Either let the CLI create a new directory:
 
 ```bash
 pnpm create uniweb my-site --template docs
 ```
 
+…or scaffold inside an existing directory (e.g., a freshly-cloned GitHub repo):
+
+```bash
+pnpm create uniweb . --template docs
+```
+
 ### Local Scripts
 
 Run these from the **project root**:
@@ -243,7 +249,7 @@ The parser extracts semantic elements from markdown—`title` from the first hea
 
 ## Foundations Are Portable
 
-The `src/` folder (your project's foundation) ships with your project as a convenience, but a foundation is a dynamically linked module (DML) with no dependency on any specific site. Sites reference foundations by configuration, not by folder proximity.
+The `src/` folder (your project's foundation) ships with your project as a convenience, but a foundation is dynamically loaded — sites reference it by configuration, not by folder proximity.
 
 **Two ways to use a foundation:**
 
@@ -308,8 +314,7 @@ You (or your dev team) write the markdown. Deploy site + foundation together.
 The shortest path to a live site is free, on GitHub Pages, with a custom domain:
 
 ```bash
-npm create uniweb my-site
-cd my-site
+uniweb create .   # from within a freshly-cloned GitHub repo
 uniweb add ci --host=github-pages
 # Commit, push to GitHub, enable Pages in repo settings → live site
 ```
@@ -374,7 +379,7 @@ Full documentation is available at **[github.com/uniweb/docs](https://github.com
 | Content Structure  | [How markdown becomes component props](https://github.com/uniweb/docs/blob/main/reference/content-structure.md) |
 | Component Metadata | [The meta.js schema](https://github.com/uniweb/docs/blob/main/reference/component-metadata.md) |
 | Site Configuration | [site.yml reference](https://github.com/uniweb/docs/blob/main/reference/site-configuration.md) |
-| CLI Commands       | [create, add, build, docs, doctor, i18n](https://github.com/uniweb/docs/blob/main/reference/cli-commands.md) |
+| CLI Commands       | [All CLI commands and flags](https://github.com/uniweb/docs/blob/main/reference/cli-commands.md) |
 | Templates          | [Built-in, official, and external templates](https://github.com/uniweb/docs/blob/main/getting-started/templates.md) |
 | Deployment         | [Two artifacts, two verbs — bundled, linked, and per-host recipes](https://github.com/uniweb/docs/blob/main/development/deploying.md) |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniweb",
-  "version": "0.12.16",
+  "version": "0.12.18",
   "description": "Create structured Vite + React sites with content/code separation",
   "type": "module",
   "bin": {
@@ -46,7 +46,7 @@
     "@uniweb/core": "0.7.11"
   },
   "peerDependencies": {
-    "@uniweb/build": "0.14.3",
+    "@uniweb/build": "0.14.4",
     "@uniweb/content-reader": "1.1.10",
     "@uniweb/semantic-parser": "1.1.17"
   },
@@ -60,5 +60,8 @@
     "@uniweb/semantic-parser": {
       "optional": true
     }
+  },
+  "scripts": {
+    "test": "node --test 'test/**/*.test.js'"
   }
 }

package/src/commands/add.js

@@ -21,10 +21,9 @@ import { scaffoldFoundation, scaffoldSite, applyContent, applyStarter, mergeTemp
 import {
   readWorkspaceConfig,
   addWorkspaceGlob,
-  discoverFoundations,
-  discoverSites,
   updateRootScripts,
 } from '../utils/config.js'
+import { discoverFoundations, discoverSites } from '../utils/discover.js'
 import { validatePackageName, getExistingPackageNames, resolveUniqueName } from '../utils/names.js'
 import { findWorkspaceRoot } from '../utils/workspace.js'
 import { detectPackageManager, filterCmd, installCmd } from '../utils/pm.js'

package/src/commands/dev.js

@@ -36,7 +36,8 @@ import { spawn } from 'node:child_process'
 import { join } from 'node:path'
 
 import { detectPackageManager, filterCmd } from '../utils/pm.js'
-import { discoverSites, readWorkspaceConfig } from '../utils/config.js'
+import { readWorkspaceConfig } from '../utils/config.js'
+import { discoverSites } from '../utils/discover.js'
 import { findWorkspaceRoot } from '../utils/workspace.js'
 import { readFlagValue } from '../utils/args.js'
 

package/src/commands/doctor.js

@@ -10,7 +10,7 @@ import { loadDeployYml } from '@uniweb/build/site'
 import { listAdapters } from '@uniweb/build/hosts'
 import { getCliVersion } from '../versions.js'
 import { readAgentsVersion } from '../utils/agents-stamp.js'
-import { discoverFoundations, discoverSites } from '../utils/config.js'
+import { discoverFoundations, discoverSites } from '../utils/discover.js'
 import { findWorkspaceRoot } from '../utils/workspace.js'
 
 /**

package/src/commands/rename.js

@@ -47,14 +47,13 @@ import yaml from 'js-yaml'
 import { isExtensionPackage } from '@uniweb/build'
 import { findWorkspaceRoot } from '../utils/workspace.js'
 import {
-  discoverFoundations,
-  discoverSites,
   readWorkspaceConfig,
   writeWorkspaceConfig,
   readRootPackageJson,
   writeRootPackageJson,
   updateRootScripts,
 } from '../utils/config.js'
+import { discoverFoundations, discoverSites } from '../utils/discover.js'
 import { getExistingPackageNames, validatePackageName } from '../utils/names.js'
 import { detectPackageManager, installCmd } from '../utils/pm.js'
 import { getCliPrefix } from '../utils/interactive.js'

package/src/framework-index.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-05-06T17:01:18.376Z",
+  "generatedAt": "2026-05-06T22:01:04.763Z",
   "packages": {
     "@uniweb/build": {
-      "version": "0.14.3",
+      "version": "0.14.4",
       "path": "framework/build",
       "deps": [
         "@uniweb/content-reader",

package/src/index.js

@@ -23,7 +23,7 @@
 
 import { existsSync, readFileSync } from 'node:fs'
 import { execSync, spawn as spawnChild } from 'node:child_process'
-import { resolve, join, relative, dirname } from 'node:path'
+import { resolve, join, relative, dirname, basename } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import prompts from 'prompts'
 // `doctor`, `add`, `publish`, and `deploy` are loaded lazily via
@@ -43,7 +43,7 @@ import {
   parseTemplateId,
 } from './templates/index.js'
 import { validateTemplate } from './templates/validator.js'
-import { scaffoldWorkspace, scaffoldFoundation, scaffoldSite, applyContent, applyStarter, mergeTemplateDependencies } from './utils/scaffold.js'
+import { scaffoldWorkspace, scaffoldFoundation, scaffoldSite, applyContent, applyStarter, mergeTemplateDependencies, getWorkspaceTemplateOutputs } from './utils/scaffold.js'
 import { detectPackageManager, filterCmd, installCmd, runCmd } from './utils/pm.js'
 import { isNonInteractive, getCliPrefix, stripNonInteractiveFlag, formatOptions } from './utils/interactive.js'
 import { findWorkspaceRoot } from './utils/workspace.js'
@@ -73,6 +73,30 @@ const TEMPLATE_CHOICES = [
   { title: 'Blank workspace', value: 'blank', description: 'Empty workspace — grow with uniweb add' },
 ]
 
+// Files that may pre-exist in the target dir during `uniweb create .` and
+// will be silently overwritten by the scaffold. Anything else colliding
+// causes the verb to abort. README and .gitignore are the only two files
+// the workspace template writes that overlap with what `gh repo create`
+// puts in a fresh repo, and the scaffold's versions are more useful in
+// this context (Vite/Node-aware .gitignore, project-shaped README).
+const IN_PLACE_OVERWRITE_ALLOWED = new Set(['README.md', '.gitignore'])
+
+/**
+ * Slugify a directory name into a valid project slug — lowercase,
+ * `[a-z0-9-]+`, no leading/trailing/duplicated hyphens. Matches the
+ * validation regex used for the interactive name prompt.
+ *
+ * @param {string} name
+ * @returns {string} Slugified name; empty if no valid characters remain.
+ */
+function slugifyName(name) {
+  return String(name)
+    .toLowerCase()
+    .replace(/[^a-z0-9-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .replace(/-{2,}/g, '-')
+}
+
 function log(message) {
   console.log(message)
 }
@@ -669,6 +693,18 @@ async function main() {
   let projectName = args[1]
   let templateType = null  // null = use new package template flow
 
+  // In-place mode: `uniweb create .` scaffolds into the current working
+  // directory instead of creating a new one. Pairs with the GitHub-first
+  // workflow where the user already cloned an empty repo (README.md and
+  // optionally .gitignore present) and wants to scaffold inside it.
+  const inPlace = projectName === '.'
+  if (inPlace) {
+    // Clear the positional so downstream logic (template prompt, name
+    // prompt, etc.) doesn't see `.` as a literal name. The actual project
+    // name is derived below from the cwd basename or `--name`.
+    projectName = null
+  }
+
   // Check for --template flag
   const templateIndex = args.indexOf('--template')
   if (templateIndex !== -1 && args[templateIndex + 1]) {
@@ -682,11 +718,14 @@ async function main() {
     }
   }
 
-  // Check for --name flag (used for project display name)
+  // Check for --name flag. Accepts both `--name foo` and `--name=foo`.
   let displayName = null
   const nameIndex = args.indexOf('--name')
   if (nameIndex !== -1 && args[nameIndex + 1]) {
     displayName = args[nameIndex + 1]
+  } else {
+    const nameEq = args.find(a => a.startsWith('--name='))
+    if (nameEq) displayName = nameEq.slice('--name='.length)
   }
 
   // Check for --blank flag
@@ -708,6 +747,28 @@ async function main() {
 
   const prefix = getCliPrefix()
 
+  // In-place: derive the project name from the cwd basename (slugified),
+  // or use --name when provided. Skip the interactive name prompt below.
+  if (inPlace) {
+    if (displayName) {
+      projectName = displayName
+    } else {
+      const dirName = basename(process.cwd())
+      const slug = slugifyName(dirName)
+      if (!slug) {
+        error(`Could not derive a valid project name from the current directory ("${dirName}").`)
+        log(`Re-run with ${colors.cyan}--name=<your-name>${colors.reset}.`)
+        process.exit(1)
+      }
+      projectName = slug
+      if (slug !== dirName) {
+        log(`${colors.dim}Project name:${colors.reset} ${slug} ${colors.dim}(slugified from "${dirName}")${colors.reset}`)
+      } else {
+        log(`${colors.dim}Project name:${colors.reset} ${slug}`)
+      }
+    }
+  }
+
   // Non-interactive: fail with actionable message instead of prompting
   if (nonInteractive && !projectName) {
     error(`Missing project name.\n`)
@@ -720,7 +781,7 @@ async function main() {
     templateType = 'starter'
   }
 
-  // Interactive prompts
+  // Interactive prompts (skipped in in-place mode — name was derived above)
   const response = await prompts([
     {
       type: projectName ? null : 'text',
@@ -773,14 +834,40 @@ async function main() {
 
   const effectiveName = displayName || projectName
 
-  // Create project directory
-  const projectDir = resolve(process.cwd(), projectName)
+  // Resolve target directory. In-place mode scaffolds into the cwd;
+  // otherwise create `./<projectName>`.
+  const projectDir = inPlace ? process.cwd() : resolve(process.cwd(), projectName)
 
-  if (existsSync(projectDir)) {
+  if (!inPlace && existsSync(projectDir)) {
     error(`Directory already exists: ${projectName}`)
     process.exit(1)
   }
 
+  if (inPlace) {
+    // Conflict check: enumerate the workspace template's would-write paths
+    // (the only stage that touches the project root) and bail if any
+    // collide with existing files outside the small allowlist.
+    //
+    // Allowlist: README.md and .gitignore overwrite cleanly. README is
+    // typically GitHub-generated boilerplate; .gitignore should be ours
+    // since the scaffold ships sensible Vite/Node ignores.
+    const outputs = await getWorkspaceTemplateOutputs({ blank: isBlank })
+    const conflicts = []
+    for (const rel of outputs) {
+      const full = resolve(projectDir, rel)
+      if (existsSync(full) && !IN_PLACE_OVERWRITE_ALLOWED.has(rel)) {
+        conflicts.push(rel)
+      }
+    }
+    if (conflicts.length > 0) {
+      error(`Cannot scaffold in place — these files would be overwritten:`)
+      for (const c of conflicts) log(`  ${colors.yellow}${c}${colors.reset}`)
+      log('')
+      log(`Move or remove them, then re-run ${colors.cyan}uniweb create .${colors.reset}.`)
+      process.exit(1)
+    }
+  }
+
   // Template routing logic
   const progressCb = (msg) => log(`  ${colors.dim}${msg}${colors.reset}`)
   const warningCb = (msg) => log(`  ${colors.yellow}Warning: ${msg}${colors.reset}`)
@@ -879,13 +966,13 @@ async function main() {
 
   if (isBlank) {
     log(`Next steps:\n`)
-    log(`  ${colors.cyan}cd ${projectName}${colors.reset}`)
+    if (!inPlace) log(`  ${colors.cyan}cd ${projectName}${colors.reset}`)
     log(`  ${colors.cyan}${prefix} add project${colors.reset}`)
     log(`  ${colors.cyan}${installCmd(pm)}${colors.reset}`)
     log(`  ${colors.cyan}${prefix} dev${colors.reset}                       ${colors.dim}# Start dev server${colors.reset}`)
   } else {
     log(`Next steps:\n`)
-    log(`  ${colors.cyan}cd ${projectName}${colors.reset}`)
+    if (!inPlace) log(`  ${colors.cyan}cd ${projectName}${colors.reset}`)
     log(`  ${colors.cyan}${installCmd(pm)}${colors.reset}`)
     log(`  ${colors.cyan}${prefix} dev${colors.reset}                       ${colors.dim}# Start dev server${colors.reset}`)
   }
@@ -979,6 +1066,7 @@ ${colors.cyan}${colors.bright}uniweb create${colors.reset} ${colors.dim}— Crea
 
 ${colors.bright}Usage:${colors.reset}
   uniweb create [name] [options]
+  uniweb create .                Scaffold into the current directory
 
 ${colors.bright}Options:${colors.reset}
   --template <type>  Project template (default: starter)
@@ -987,13 +1075,24 @@ ${colors.bright}Options:${colors.reset}
                      npm:      @scope/template-name
                      GitHub:   github:user/repo or https://github.com/user/repo
   --blank            Create an empty workspace (grow with \`uniweb add\`)
-  --name <name>      Project display name
+  --name <name>      Project name (overrides slugified basename when used with \`.\`)
   --no-git           Skip git repository initialization
 
+${colors.bright}In-place mode (\`uniweb create .\`):${colors.reset}
+  Pairs with the GitHub-first workflow — clone an empty repo locally
+  (README, optional .gitignore), then scaffold inside it. Project name
+  is the cwd basename, slugified to a valid npm name. Pass \`--name\` to
+  override. Pre-existing \`README.md\` and \`.gitignore\` are overwritten;
+  any other collision aborts with the list of conflicting files. Skips
+  \`git init\` when a \`.git/\` directory already exists.
+
 ${colors.bright}Examples:${colors.reset}
   uniweb create my-project                       # Foundation + site + starter content
   uniweb create my-project --template marketing  # Official template
   uniweb create my-project --blank               # Empty workspace
+  uniweb create .                                # Scaffold into current dir
+  uniweb create . --template docs                # In place + a content template
+  uniweb create . --name=my-app                  # In place, explicit slug
 `,
     dev: `
 ${colors.cyan}${colors.bright}uniweb dev${colors.reset} ${colors.dim}— Start a dev server for a site${colors.reset}

package/src/templates/processor.js

@@ -224,6 +224,53 @@ 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)
+ *   - `template.json` is excluded
+ *   - `skip` filenames are excluded by their post-rename name
+ *
+ * Returns relative paths (POSIX-style separators on POSIX, native on Windows
+ * — `path.join` semantics). Used by the in-place create flow to detect
+ * conflicts before any I/O begins.
+ *
+ * @param {string} sourcePath - Source template directory
+ * @param {Object} [options]
+ * @param {string[]} [options.skip] - Output filenames to exclude
+ * @returns {Promise<string[]>}
+ */
+export async function enumerateTemplateOutputs(sourcePath, options = {}) {
+  const { skip = [] } = options
+  const outputs = []
+  await enumerateInto(sourcePath, '', outputs, skip)
+  return outputs
+}
+
+async function enumerateInto(sourcePath, relPath, outputs, skip) {
+  const entries = await fs.readdir(sourcePath, { withFileTypes: true })
+  for (const entry of entries) {
+    const sourceName = entry.name
+    if (entry.isDirectory()) {
+      const targetName = sourceName.startsWith('_') && !sourceName.startsWith('__')
+        ? `.${sourceName.slice(1)}`
+        : sourceName
+      await enumerateInto(
+        path.join(sourcePath, sourceName),
+        relPath ? path.join(relPath, targetName) : targetName,
+        outputs,
+        skip,
+      )
+    } else {
+      if (sourceName === 'template.json') continue
+      const outputName = sourceName.endsWith('.hbs') ? sourceName.slice(0, -4) : sourceName
+      if (skip.includes(outputName)) continue
+      outputs.push(relPath ? path.join(relPath, outputName) : outputName)
+    }
+  }
+}
+
 /**
  * Clear the template cache
  */

package/src/utils/config.js

@@ -1,8 +1,17 @@
 /**
  * Workspace Config Management
  *
- * Read/write pnpm-workspace.yaml and root package.json.
- * Used by both `create` and `add` commands.
+ * Read/write pnpm-workspace.yaml and root package.json, plus URL config
+ * for the platform backend / registry. Used by both `create` and `add`
+ * commands.
+ *
+ * This module is on the CLI's startup path (statically imported by
+ * `commands/login.js`, which is loaded by `src/index.js`). It MUST NOT
+ * import any optional peer dependency — most importantly `@uniweb/build`,
+ * which is absent in `npx uniweb create` scratch dirs and global
+ * installs. Workspace package discovery (which does need `@uniweb/build`)
+ * lives in `./discover.js` and is loaded only by commands that already
+ * require a project context.
  */
 
 import { existsSync, readFileSync } from 'node:fs'
@@ -10,7 +19,6 @@ 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 ──────────────────────────────────────────────
@@ -223,63 +231,6 @@ export async function updateRootScripts(rootDir, sites, pm = 'pnpm') {
   await writeRootPackageJson(rootDir, pkg)
 }
 
-/**
- * Discover foundations in the workspace
- * @param {string} rootDir - Workspace root directory
- * @returns {Promise<Array<{name: string, path: string}>>}
- */
-export async function discoverFoundations(rootDir) {
-  return discoverByKind(rootDir, 'foundation')
-}
-
-/**
- * Discover sites in the workspace
- * @param {string} rootDir - Workspace root directory
- * @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 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
-
-      // 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 })
-    }
-  }
-
-  return out
-}
-
 // Resolve a workspace glob pattern to actual directories
 export async function resolveGlob(rootDir, pattern) {
   const clean = pattern.replace(/^["']|["']$/g, '')

package/src/utils/discover.js

@@ -0,0 +1,75 @@
+/**
+ * Workspace package discovery
+ *
+ * Walks the workspace globs and classifies each package as a site or
+ * foundation using `classifyPackage` from `@uniweb/build` — the canonical
+ * classifier shared with the build pipeline. It keys on real signals
+ * (site.yml for sites, generated entry for foundations) rather than which
+ * `@uniweb/*` packages happen to be in dependencies, so templates whose
+ * sites pull runtime transitively through the foundation (e.g., marketing)
+ * are classified correctly.
+ *
+ * Why this lives in its own file: `@uniweb/build` is an OPTIONAL peer
+ * dependency of the CLI. The CLI's startup path (`src/index.js` and
+ * everything it statically imports) MUST run in environments where
+ * `@uniweb/build` is not installed — `npx uniweb create` in a scratch
+ * dir, `npm i -g uniweb` before any project exists, etc. Anything that
+ * imports `@uniweb/build` therefore must NOT be reachable from the
+ * startup graph; it must be loaded dynamically by commands that already
+ * require a project context. Keeping discovery in this dedicated module
+ * makes that boundary structural rather than conventional.
+ */
+
+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'
+
+/**
+ * Discover foundations in the workspace.
+ * @param {string} rootDir - Workspace root directory
+ * @returns {Promise<Array<{name: string, path: string}>>}
+ */
+export async function discoverFoundations(rootDir) {
+  return discoverByKind(rootDir, 'foundation')
+}
+
+/**
+ * Discover sites in the workspace.
+ * @param {string} rootDir - Workspace root directory
+ * @returns {Promise<Array<{name: string, path: string}>>}
+ */
+export async function discoverSites(rootDir) {
+  return discoverByKind(rootDir, 'site')
+}
+
+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
+
+      // 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 })
+    }
+  }
+
+  return out
+}

package/src/utils/names.js

@@ -5,7 +5,8 @@
  * and detects collisions with existing workspace packages.
  */
 
-import { discoverFoundations, discoverSites, readWorkspaceConfig, resolveGlob } from './config.js'
+import { readWorkspaceConfig, resolveGlob } from './config.js'
+import { discoverFoundations, discoverSites } from './discover.js'
 import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import { join } from 'node:path'

package/src/utils/scaffold.js

@@ -11,7 +11,7 @@ import { join, dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import yaml from 'js-yaml'
 import Handlebars from 'handlebars'
-import { copyTemplateDirectory, registerVersions } from '../templates/processor.js'
+import { copyTemplateDirectory, enumerateTemplateOutputs, registerVersions } from '../templates/processor.js'
 import { getVersionsForTemplates, getCliVersion } from '../versions.js'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
@@ -48,6 +48,28 @@ export async function scaffoldWorkspace(targetDir, context, options = {}) {
   })
 }
 
+/**
+ * Return the relative paths the workspace template would write into the
+ * project root, given the same skip rules `scaffoldWorkspace` applies.
+ * Used by the in-place create flow (`uniweb create .`) to detect conflicts
+ * before any I/O begins.
+ *
+ * Only the workspace template's outputs are enumerated. The foundation,
+ * site, and starter stages write into newly-created subdirectories
+ * (`src/`, `site/`) that don't pre-exist in a target like a fresh GitHub
+ * clone, so they can't conflict.
+ *
+ * @param {Object} [options]
+ * @param {boolean} [options.blank] - True when scaffolding a blank workspace
+ *   (no packages yet) — skips `pnpm-workspace.yaml`, mirroring scaffoldWorkspace.
+ * @returns {Promise<string[]>}
+ */
+export async function getWorkspaceTemplateOutputs({ blank = false } = {}) {
+  const skip = blank ? ['pnpm-workspace.yaml'] : []
+  const templatePath = join(TEMPLATES_DIR, 'workspace')
+  return enumerateTemplateOutputs(templatePath, { skip })
+}
+
 /**
  * Scaffold a foundation from the foundation package template
  *