create-icebreaker 0.0.0 → 0.1.0

package/README.md

@@ -1,23 +1,33 @@
 # create-icebreaker
 
-One-shot bootstrapper for the icebreaker monorepo template. It clones the template repo, removes `.git`, and optionally runs the built-in cleanup before you install dependencies.
+Interactive bootstrapper for the icebreaker monorepo template. It scaffolds from the npm package and trims templates based on your selections.
 
 ## Usage
 
-- `pnpm create icebreaker my-app`
-- `npm create icebreaker@latest my-app`
+- `pnpm create icebreaker`
+- `npm create icebreaker@latest`
 
 By default this:
 
-- clones `sonofmagic/monorepo-template` (branch `main`) into `my-app`
-- strips the git history
-- runs `pnpm dlx @icebreakers/monorepo@latest clean --yes`
+- uses npm templates by default (no GitHub needed)
+- asks for the project directory (defaults to `icebreaker-monorepo`)
+- asks which templates to keep (default keeps none)
+- updates the root `package.json` name
+
+## Templates
+
+Available template keys:
+
+- `unbuild`
+- `tsup`
+- `tsdown`
+- `vue-lib`
+- `vue-hono`
+- `hono-server`
+- `vitepress`
+- `cli`
 
 ## Flags
 
-- `--repo <git-url-or-owner/name>`: clone a different repo
-- `--branch <branch-or-tag>`: choose a branch or tag
-- `--no-clean`: skip running `monorepo clean`
-- `--include-private`: include private packages when cleaning
+- `--templates <list>`: comma-separated template keys or indexes to keep (e.g. `tsup,vue-hono` or `1,5`)
 - `--force`: overwrite a non-empty target directory
-- `--agent <pnpm|npm>`: force which tool to run the cleanup with

package/bin/create-icebreaker.js

@@ -1,222 +1,2 @@
 #!/usr/bin/env node
-import { spawn } from 'node:child_process'
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import process from 'node:process'
-
-const DEFAULT_REPO = 'sonofmagic/monorepo-template'
-const DEFAULT_BRANCH = 'main'
-
-function printHelp() {
-  console.log([
-    'Usage: create-icebreaker [dir] [--repo <repo>] [--branch <branch>]',
-    'Options:',
-    '  --repo <repo>          GitHub repo or git url to clone (default sonofmagic/monorepo-template)',
-    '  --branch <branch>      Branch or tag to checkout (default main)',
-    '  --no-clean             Skip running monorepo clean after download',
-    '  --include-private      Run clean with private packages included',
-    '  --force                Remove existing target directory before cloning',
-    '  --agent <pnpm|npm>     Force package manager used for cleanup (default auto-detect)',
-    '  -h, --help             Show this help message',
-  ].join('\n'))
-}
-
-function parseArgs(argv) {
-  const options = {
-    targetDir: 'icebreaker-monorepo',
-    repo: DEFAULT_REPO,
-    branch: DEFAULT_BRANCH,
-    clean: true,
-    force: false,
-    includePrivate: false,
-    agent: undefined,
-  }
-  const positionals = []
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i]
-    if (arg === '--repo' && argv[i + 1]) {
-      options.repo = argv[++i]
-      continue
-    }
-    if (arg.startsWith('--repo=')) {
-      options.repo = arg.split('=')[1] || options.repo
-      continue
-    }
-    if (arg === '--branch' && argv[i + 1]) {
-      options.branch = argv[++i]
-      continue
-    }
-    if (arg.startsWith('--branch=')) {
-      options.branch = arg.split('=')[1] || options.branch
-      continue
-    }
-    if (arg === '--no-clean') {
-      options.clean = false
-      continue
-    }
-    if (arg === '--clean') {
-      options.clean = true
-      continue
-    }
-    if (arg === '--include-private') {
-      options.includePrivate = true
-      continue
-    }
-    if (arg === '--force') {
-      options.force = true
-      continue
-    }
-    if (arg === '--agent' && argv[i + 1]) {
-      options.agent = argv[++i]
-      continue
-    }
-    if (arg.startsWith('--agent=')) {
-      options.agent = arg.split('=')[1] || options.agent
-      continue
-    }
-    if (arg === '-h' || arg === '--help') {
-      options.help = true
-      continue
-    }
-    if (!arg.startsWith('-')) {
-      positionals.push(arg)
-    }
-  }
-  if (positionals.length) {
-    options.targetDir = positionals[0]
-  }
-  return options
-}
-
-function normalizeRepo(repo) {
-  if (repo.startsWith('http')) {
-    return repo
-  }
-  if (repo.startsWith('gh:')) {
-    return `https://github.com/${repo.slice(3)}.git`
-  }
-  if (/^[\w.-]+\/[\w.-]+$/.test(repo)) {
-    return `https://github.com/${repo}.git`
-  }
-  return repo
-}
-
-async function isEmptyDir(dir) {
-  try {
-    const entries = await fs.readdir(dir)
-    return entries.length === 0
-  }
-  catch (error) {
-    if (error && error.code === 'ENOENT') {
-      return true
-    }
-    throw error
-  }
-}
-
-async function prepareTarget(dir, force) {
-  const empty = await isEmptyDir(dir)
-  if (empty) {
-    await fs.mkdir(dir, { recursive: true })
-    return
-  }
-  if (!force) {
-    throw new Error(`Target directory ${dir} is not empty. Pass --force to overwrite.`)
-  }
-  await fs.rm(dir, { recursive: true, force: true })
-  await fs.mkdir(dir, { recursive: true })
-}
-
-function runCommand(command, args, options) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      stdio: 'inherit',
-      ...options,
-    })
-    child.on('error', reject)
-    child.on('close', (code) => {
-      if (code && code !== 0) {
-        reject(new Error(`${command} ${args.join(' ')} exited with code ${code}`))
-        return
-      }
-      resolve()
-    })
-  })
-}
-
-async function cloneRepo(repo, branch, targetDir) {
-  const normalized = normalizeRepo(repo)
-  console.log(`Cloning ${normalized} (branch ${branch})...`)
-  await runCommand('git', ['clone', '--depth', '1', '--branch', branch, normalized, targetDir])
-  await fs.rm(path.join(targetDir, '.git'), { recursive: true, force: true })
-}
-
-function detectAgent(userAgent) {
-  if (!userAgent) {
-    return 'pnpm'
-  }
-  const first = userAgent.split(' ')[0] || ''
-  if (first.startsWith('pnpm/')) {
-    return 'pnpm'
-  }
-  if (first.startsWith('npm/')) {
-    return 'npm'
-  }
-  return 'pnpm'
-}
-
-function getCleanCommand(agent, includePrivate) {
-  const usePnpm = agent === 'pnpm'
-  const runner = usePnpm ? 'pnpm' : 'npx'
-  const args = usePnpm
-    ? ['dlx', '@icebreakers/monorepo@latest', 'clean', '--yes']
-    : ['--yes', '@icebreakers/monorepo@latest', 'clean', '--yes']
-  if (includePrivate) {
-    args.push('--include-private')
-  }
-  return { runner, args }
-}
-
-async function runClean(targetDir, agent, includePrivate) {
-  const { runner, args } = getCleanCommand(agent, includePrivate)
-  console.log(`Running ${runner} ${args.join(' ')} in ${targetDir}`)
-  await runCommand(runner, args, { cwd: targetDir })
-}
-
-function printNextSteps(targetDir, cleanRan) {
-  const relative = path.relative(process.cwd(), targetDir) || '.'
-  console.log('\nAll set! Next steps:')
-  console.log(`  cd ${relative}`)
-  if (!cleanRan) {
-    console.log('  pnpm dlx @icebreakers/monorepo@latest clean --yes')
-  }
-  console.log('  pnpm install')
-  console.log('  pnpm dev')
-}
-
-async function main() {
-  const parsed = parseArgs(process.argv.slice(2))
-  if (parsed.help) {
-    printHelp()
-    return
-  }
-  const targetDir = path.resolve(process.cwd(), parsed.targetDir)
-  try {
-    await prepareTarget(targetDir, parsed.force)
-    await cloneRepo(parsed.repo, parsed.branch, targetDir)
-    if (parsed.clean) {
-      const agent = parsed.agent || detectAgent(process.env.npm_config_user_agent)
-      await runClean(targetDir, agent, parsed.includePrivate)
-    }
-    else {
-      console.log('Skip clean step per --no-clean')
-    }
-    printNextSteps(targetDir, parsed.clean)
-  }
-  catch (error) {
-    console.error('[create-icebreaker]', error?.message || error)
-    process.exitCode = 1
-  }
-}
-
-main()
+import '../dist/index.mjs'

package/dist/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index.mjs

@@ -0,0 +1,186 @@
+import path from "node:path";
+import process from "node:process";
+import { Command, checkbox, input, shouldSkipTemplatePath, skeletonDir, templateChoices, templatesDir, toWorkspaceGitignorePath } from "@icebreakers/monorepo-templates";
+import fs from "node:fs/promises";
+
+//#region src/constants.ts
+const DEFAULT_TARGET = "icebreaker-monorepo";
+
+//#endregion
+//#region src/fs-utils.ts
+async function isEmptyDir(dir) {
+	try {
+		return (await fs.readdir(dir)).length === 0;
+	} catch (error) {
+		if (error && error.code === "ENOENT") return true;
+		throw error;
+	}
+}
+async function prepareTarget(dir, force) {
+	if (await isEmptyDir(dir)) {
+		await fs.mkdir(dir, { recursive: true });
+		return;
+	}
+	if (!force) throw new Error(`Target directory ${dir} is not empty. Pass --force to overwrite.`);
+	await fs.rm(dir, {
+		recursive: true,
+		force: true
+	});
+	await fs.mkdir(dir, { recursive: true });
+}
+async function copyDirContents(sourceDir, targetDir, rootDir = sourceDir) {
+	await fs.mkdir(targetDir, { recursive: true });
+	const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+	for (const entry of entries) {
+		const from = path.join(sourceDir, entry.name);
+		if (shouldSkipTemplatePath(rootDir, from)) continue;
+		const targetName = toWorkspaceGitignorePath(entry.name);
+		const to = path.join(targetDir, targetName);
+		if (entry.isDirectory()) {
+			await copyDirContents(from, to, rootDir);
+			continue;
+		}
+		if (entry.isSymbolicLink()) {
+			const link = await fs.readlink(from);
+			await fs.symlink(link, to);
+			continue;
+		}
+		await fs.cp(from, to);
+	}
+}
+
+//#endregion
+//#region src/package-json.ts
+async function updateRootPackageJson(targetDir, projectName) {
+	const pkgPath = path.join(targetDir, "package.json");
+	const raw = await fs.readFile(pkgPath, "utf8");
+	const pkg = JSON.parse(raw);
+	pkg.name = projectName;
+	const devDependencies = pkg.devDependencies;
+	if (devDependencies && devDependencies["@icebreakers/monorepo"]) {
+		delete devDependencies["@icebreakers/monorepo"];
+		if (Object.keys(devDependencies).length === 0) delete pkg.devDependencies;
+	}
+	const scripts = pkg.scripts;
+	if (scripts) {
+		const nextScripts = {};
+		for (const [key, value] of Object.entries(scripts)) {
+			if (typeof value === "string" && value.includes("monorepo")) continue;
+			nextScripts[key] = value;
+		}
+		if (Object.keys(nextScripts).length) pkg.scripts = nextScripts;
+		else delete pkg.scripts;
+	}
+	await fs.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`, "utf8");
+}
+
+//#endregion
+//#region src/templates.ts
+function parseTemplateInput(input$1) {
+	const selections = /* @__PURE__ */ new Set();
+	const unknown = [];
+	const tokens = input$1.split(/[,\\s]+/).map((token) => token.trim()).filter(Boolean);
+	for (const token of tokens) {
+		const normalized = token.toLowerCase();
+		if (/^\\d+$/.test(normalized)) {
+			const choice = templateChoices[Number(normalized) - 1];
+			if (choice) selections.add(choice.key);
+			else unknown.push(token);
+			continue;
+		}
+		const match = templateChoices.find((item) => item.key === normalized);
+		if (match) selections.add(match.key);
+		else unknown.push(token);
+	}
+	return {
+		selections: Array.from(selections),
+		unknown
+	};
+}
+function resolveTemplateSelections(input$1) {
+	if (!input$1) return {
+		selections: [],
+		unknown: []
+	};
+	return parseTemplateInput(input$1);
+}
+
+//#endregion
+//#region src/prompts.ts
+async function promptTargetDir(defaultDir) {
+	return ((await input({
+		message: `项目创建目录（默认 ${defaultDir}）：`,
+		default: defaultDir
+	}))?.trim?.() ?? defaultDir) || defaultDir;
+}
+async function promptTemplates() {
+	return await checkbox({
+		message: "请选择要保留的模板（默认不选择）：",
+		choices: templateChoices.map((item) => ({
+			name: `${item.key} - ${item.label}`,
+			value: item.key
+		}))
+	});
+}
+
+//#endregion
+//#region src/source-npm.ts
+async function copySelectedTemplates(targetDir, selectedTemplates) {
+	if (!selectedTemplates.length) return;
+	const selected = new Set(selectedTemplates);
+	for (const template of templateChoices) {
+		if (!selected.has(template.key)) continue;
+		await copyDirContents(path.join(templatesDir, template.source), path.join(targetDir, template.target));
+	}
+}
+async function scaffoldFromNpm(targetDir, selectedTemplates) {
+	await copyDirContents(skeletonDir, targetDir);
+	await copySelectedTemplates(targetDir, selectedTemplates);
+}
+
+//#endregion
+//#region src/index.ts
+function printNextSteps(targetDir) {
+	const relative = path.relative(process.cwd(), targetDir) || ".";
+	process.stdout.write([
+		"",
+		"All set! Next steps:",
+		`  cd ${relative}`,
+		"  pnpm install",
+		"  pnpm dev",
+		""
+	].join("\n"));
+}
+async function runCreate(targetDirInput, options) {
+	const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+	let targetInput = targetDirInput || DEFAULT_TARGET;
+	if (isInteractive) targetInput = await promptTargetDir(targetInput);
+	let selectedTemplates = [];
+	if (options.templates) {
+		const { selections, unknown } = resolveTemplateSelections(options.templates);
+		if (unknown.length) process.stderr.write(`忽略未知模板：${unknown.join(", ")}\n`);
+		selectedTemplates = selections;
+	} else if (isInteractive) selectedTemplates = await promptTemplates();
+	const targetDir = path.resolve(process.cwd(), targetInput);
+	const projectName = path.basename(targetDir) || targetInput;
+	await prepareTarget(targetDir, Boolean(options.force));
+	await scaffoldFromNpm(targetDir, selectedTemplates);
+	await updateRootPackageJson(targetDir, projectName);
+	printNextSteps(targetDir);
+}
+const program = new Command();
+program.name("create-icebreaker").description("Bootstrap the icebreaker monorepo template").argument("[dir]", "Target directory", DEFAULT_TARGET).option("-t, --templates <list>", "Comma-separated template keys or indexes to keep").option("-f, --force", "Remove existing target directory before scaffolding", false).action(async (dir, options) => {
+	try {
+		await runCreate(dir, options);
+	} catch (error) {
+		process.stderr.write(`[create-icebreaker] ${error instanceof Error ? error.message : error}\n`);
+		process.exitCode = 1;
+	}
+});
+program.parseAsync(process.argv).catch((error) => {
+	process.stderr.write(`[create-icebreaker] ${error instanceof Error ? error.message : error}\n`);
+	process.exitCode = 1;
+});
+
+//#endregion
+export {  };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-icebreaker",
   "type": "module",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "description": "Bootstrap the icebreaker monorepo template via npm create/pnpm create with optional cleanup",
   "author": "ice breaker <1324318532@qq.com>",
   "license": "MIT",
@@ -24,15 +24,22 @@
     "create-icebreaker": "bin/create-icebreaker.js"
   },
   "files": [
-    "bin"
+    "bin",
+    "dist"
   ],
   "engines": {
     "node": ">=18.0.0"
   },
+  "dependencies": {
+    "@icebreakers/monorepo-templates": "0.1.0"
+  },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
+    "dev": "tsdown --watch --sourcemap",
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json",
     "lint": "eslint .",
     "test": "vitest run --passWithNoTests"
   }