create-octane-xplat 0.7.3 → 0.10.0

package/README.md

@@ -3,20 +3,34 @@
 > Get a TypeScript app running, then build its first useful flow with your
 > coding agent.
 
-xplat's target direction spans web, iOS, Android, macOS, and Windows. This
-starter configures **web, iOS, and Android**. macOS is a separate experiment;
-Windows has a separate experimental scaffold with runtime verification pending. See
+Xplat's target direction spans web, iOS, Android, macOS, Windows, and Linux.
+This starter configures **web, iOS, and Android**. macOS, Windows, and Linux
+are separate experiments — an AppKit host, a WinUI 3 scaffold with runtime
+verification pending, and a WebKitGTK webview host. See
 [target support](https://octane-xplat.goddardai.org/spec#choose-your-targets).
 The framework is `0.x` and its API surface is still changing.
 
-With Node.js and pnpm installed:
+With Node.js and pnpm 11.24.0 installed:
 
 ```sh
 pnpm create octane-xplat my-app
 ```
 
+The creator asks which platforms to target — web, iOS, and Android are all
+pre-selected. Pass `--targets` to skip the prompt:
+
+```sh
+pnpm create octane-xplat my-app --targets web          # web only
+pnpm create octane-xplat my-app --targets web,android  # web + Android
+```
+
+Platforms skipped here can be enabled later with `pnpm xplat add <platform>`
+inside the app. (Non-interactive runs without `--targets` scaffold all
+three.)
+
 The creator copies the template, installs dependencies with pnpm, and starts
-the web dev server. Open the printed URL and open `my-app` in your agent.
+the web dev server when the web target is included. Open the printed URL and
+open `my-app` in your agent.
 Ask it to read `AGENTS.md` and `.agents/skills/xplat/SKILL.md`, then build a
 packing checklist with add, pack, and remove actions using in-memory state.
 Check the result before asking for the next feature: add “Passport” and
@@ -25,6 +39,10 @@ clear the list in this in-memory version. The
 [first-flow guide](https://octane-xplat.goddardai.org/toolchain#build-and-check-your-first-flow)
 includes the full prompt and failure checks.
 
+The generated app pins pnpm 11.24.0. Its `pnpm-workspace.yaml` loads
+`@octane-xplat/patches` as a `configDependencies` package, making the
+framework patches available during the first install.
+
 Leave the server running while you edit. After stopping it, restart from the
 app directory:
 
@@ -33,18 +51,20 @@ cd my-app
 pnpm dev            # web
 ```
 
-From that directory, these commands run other targets or check the app:
+From that directory, these commands run other targets or check the app — the
+`dev:*`/`build:*` entries exist only for platforms chosen at create time
+(`pnpm xplat add` adds the rest later):
 
 ```sh
 pnpm dev:ios        # needs macOS, Xcode, and NativeScript setup
 pnpm dev:android    # needs Android SDK, compatible JDK, and NativeScript setup
 pnpm lint
-pnpm typecheck      # web + native tsconfigs
+pnpm typecheck      # every enabled tsconfig
 pnpm build          # web production bundle
 ```
 
 [Get a working app and iterate](https://octane-xplat.goddardai.org/toolchain)
 provides prerequisites, live-update boundaries, and version guidance. The
-starter's xplat skill is included; NativeScript's official skills are optional
+starter's Xplat skill is included; NativeScript's official skills are optional
 and installed separately. Ask your agent to report checks and targets actually
 run. [llms.txt](https://octane-xplat.goddardai.org/llms.txt) indexes the docs.

package/index.mjs

@@ -1,31 +1,129 @@
 #!/usr/bin/env node
-import { existsSync, readdirSync, cpSync, renameSync } from 'node:fs'
-import { dirname, join, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { existsSync, readdirSync } from 'node:fs'
+import { resolve } from 'node:path'
 import { spawnSync } from 'node:child_process'
+import {
+	composeTargets,
+	defaultTargets,
+	resolveTargets,
+	selectableTargets,
+	targets,
+} from './scaffold.mjs'
 
-const dir = resolve(process.argv[2] ?? 'octane-xplat-app')
+const argv = process.argv.slice(2)
+const noInstall = argv.includes('--no-install')
+const targetsIndex = argv.findIndex((arg) => arg === '--targets' || arg.startsWith('--targets='))
+const targetsValueIndex =
+	targetsIndex !== -1 && argv[targetsIndex] === '--targets' ? targetsIndex + 1 : -1
+
+const targetsArg =
+	targetsIndex === -1
+		? undefined
+		: targetsValueIndex !== -1
+			? argv[targetsValueIndex]
+			: argv[targetsIndex].slice('--targets='.length)
+
+if (targetsIndex !== -1 && (targetsArg === undefined || targetsArg.startsWith('-'))) {
+	console.error(`✗ --targets needs a comma list: ${selectableTargets.join(', ')}`)
+	process.exit(1)
+}
+
+const positional = argv.filter((arg, i) => !arg.startsWith('-') && i !== targetsValueIndex)
+const dir = resolve(positional[0] ?? 'octane-xplat-app')
 
 if (existsSync(dir) && readdirSync(dir).length > 0) {
 	console.error(`✗ ${dir} exists and is not empty`)
 	process.exit(1)
 }
 
-const template = join(dirname(fileURLToPath(import.meta.url)), 'template')
-cpSync(template, dir, { recursive: true })
-// npm packs .gitignore as a renamed file or drops it — ship it undotted.
-try {
-	renameSync(join(dir, 'gitignore'), join(dir, '.gitignore'))
-} catch {}
+const parseTargets = (value) => {
+	const ids = value
+		.split(',')
+		.map((s) => s.trim())
+		.filter(Boolean)
+
+	if (ids.length === 0) {
+		throw new Error(`--targets needs a comma list: ${selectableTargets.join(', ')}`)
+	}
+
+	for (const id of ids) {
+		if (!selectableTargets.includes(id)) {
+			throw new Error(
+				`unknown target "${id}" — expected a comma list of: ${selectableTargets.join(', ')}`,
+			)
+		}
+	}
+
+	return resolveTargets(ids)
+}
+
+let ids
+if (targetsArg !== undefined) {
+	try {
+		ids = parseTargets(targetsArg)
+	} catch (error) {
+		console.error(`✗ ${error.message}`)
+		process.exit(1)
+	}
+} else if (process.stdout.isTTY) {
+	// Lazy: the extracted tarball has no installed deps — only the interactive
+	// path needs @clack/prompts (verify-consumer runs the bin dep-free).
+	const p = await import('@clack/prompts')
+	p.intro('create-octane-xplat')
+	const picked = await p.multiselect({
+		message: 'Target platforms',
+		options: selectableTargets.map((id) => ({
+			value: id,
+			label: targets[id].label,
+			hint: targets[id].note,
+		})),
+		initialValues: [...defaultTargets],
+		required: true,
+	})
 
-console.log(`\n✓ scaffolded ${dir}`)
+	if (p.isCancel(picked)) {
+		p.cancel('Cancelled')
+		process.exit(0)
+	}
+
+	ids = picked
+} else {
+	ids = defaultTargets
+}
+
+composeTargets(ids, dir)
+
+console.log(
+	`\n✓ scaffolded ${dir} (${[...new Set(resolveTargets(ids))].filter((id) => !targets[id].hidden).join(', ')})`,
+)
+
+if (noInstall) {
+	console.log('\nSkipped install (--no-install). To run manually:')
+	printNextSteps(dir, ids)
+	process.exit(0)
+}
 
 const install = spawnSync('pnpm', ['install'], { cwd: dir, stdio: 'inherit' })
 if (install.status !== 0) {
 	console.log(`\nInstall didn't finish (pnpm missing?). To run manually:`)
-	console.log(`  cd ${dir}\n  pnpm install\n  pnpm dev`)
+	printNextSteps(dir, ids)
 	process.exit(install.status ?? 1)
 }
 
-console.log('\n✓ installed — starting dev server (Ctrl+C to stop)\n')
-spawnSync('pnpm', ['dev'], { cwd: dir, stdio: 'inherit' })
+if (ids.includes('web')) {
+	console.log('\n✓ installed — starting dev server (Ctrl+C to stop)\n')
+	spawnSync('pnpm', ['dev'], { cwd: dir, stdio: 'inherit' })
+} else {
+	console.log('\n✓ installed. To run:')
+	printNextSteps(dir, ids)
+}
+
+function printNextSteps(dir, ids) {
+	console.log(`  cd ${dir}\n  pnpm install`)
+	if (ids.includes('web')) {
+		console.log('  pnpm dev')
+	} else {
+		// No web entry — `xplat dev` discovers whichever native targets exist.
+		console.log('  pnpm xplat dev')
+	}
+}

package/package.json

@@ -1,22 +1,22 @@
 {
   "name": "create-octane-xplat",
-  "version": "0.7.3",
+  "version": "0.10.0",
   "description": "Scaffold a minimal @octane-xplat/ui app — one Octane codebase for web + iOS + Android",
   "keywords": [
-    "octane",
-    "xplat",
-    "cross-platform",
     "create",
+    "cross-platform",
+    "init",
+    "octane",
+    "project-generator",
     "scaffolding",
     "starter-template",
-    "project-generator",
-    "init"
+    "xplat"
   ],
-  "license": "MIT",
   "homepage": "https://github.com/octane-xplat/octane-xplat/tree/main/packages/create",
+  "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/octane-xplat/octane-xplat.git",
+    "url": "https://github.com/octane-xplat/octane-xplat",
     "directory": "packages/create"
   },
   "bin": {
@@ -24,10 +24,17 @@
   },
   "files": [
     "index.mjs",
+    "scaffold.mjs",
     "template"
   ],
   "type": "module",
+  "exports": {
+    "./scaffold": "./scaffold.mjs"
+  },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@clack/prompts": "1.8.1"
   }
 }