@theholocron/cli 2.0.0-alpha.76 → 2.0.0-alpha.77

package/dist/cli.mjs

@@ -10,9 +10,9 @@ import { AuthError, ProviderApiError, ProviderApiError as ProviderApiError$1 } f
 import { Entry, findCredentials } from "@napi-rs/keyring";
 import ora from "ora";
 import chalk from "chalk";
+import { execFile, execFileSync, spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { createGitHubClient } from "@theholocron/github-client";
-import { execFile, execFileSync, spawnSync } from "node:child_process";
 import { access, copyFile, mkdir, readFile, readdir, rm, stat, symlink, unlink, writeFile } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
 import { promisify } from "node:util";
@@ -433,6 +433,210 @@ async function tryLoadHint(importer, packageName) {
 	}
 }
 //#endregion
+//#region src/commands/new.ts
+/**
+* `holocron new <type> <name>` — create a GitHub repo from a template and
+* bootstrap it by replacing all template-slug casing variants with the new
+* project name.
+*
+* Flow:
+*   1. Preflight — verify `gh` CLI is available.
+*   2. Resolve type, name, description (prompt via readline if missing).
+*   3. `gh repo create <org>/<name> --template <org>/<type>-template --private --clone`
+*      → clones to `<cwd>/<name>/`
+*   4. Detect template slug from cloned package.json.
+*   5. Replace all casing variants of the slug across every text file.
+*   6. Replace `<description>` placeholder if a description was given.
+*   7. Commit the patched files (-s for DCO).
+*   8. Unless --no-verify: `pnpm install` in the new repo.
+*   9. Print next steps.
+*/
+var NewError = class extends Error {
+	name = "NewError";
+};
+function cap(word) {
+	return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+}
+/**
+* Derive all common casing variants of a kebab-case slug (e.g.
+* "cli-template") and map each to the corresponding form of a
+* kebab-case name (e.g. "my-tool").
+*
+* Returns search→replacement pairs, deduplicating single-word slugs
+* that would otherwise produce identical entries.
+*/
+function deriveVariants(slug, name) {
+	const sw = slug.split("-");
+	const nw = name.split("-");
+	const pairs = [
+		[slug, name],
+		[sw.join("_"), nw.join("_")],
+		[sw.join("_").toUpperCase(), nw.join("_").toUpperCase()],
+		[sw.map(cap).join(""), nw.map(cap).join("")],
+		[sw[0].toLowerCase() + sw.slice(1).map(cap).join(""), nw[0].toLowerCase() + nw.slice(1).map(cap).join("")],
+		[sw.map(cap).join(" "), nw.map(cap).join(" ")]
+	];
+	const seen = /* @__PURE__ */ new Set();
+	return pairs.filter(([s]) => {
+		if (seen.has(s)) return false;
+		seen.add(s);
+		return true;
+	});
+}
+const SKIP_DIRS$1 = /* @__PURE__ */ new Set([
+	".git",
+	"node_modules",
+	"dist",
+	".turbo"
+]);
+function defaultWalkFiles$1(dir) {
+	const results = [];
+	for (const entry of readdirSync(dir)) {
+		if (SKIP_DIRS$1.has(entry)) continue;
+		const full = path.join(dir, entry);
+		const stat = statSync(full);
+		if (stat.isDirectory()) results.push(...defaultWalkFiles$1(full));
+		else if (stat.isFile()) results.push(full);
+	}
+	return results;
+}
+function isBinary(content) {
+	for (let i = 0; i < Math.min(content.length, 8e3); i++) if (content.charCodeAt(i) === 0) return true;
+	return false;
+}
+function patchFiles(dir, variants, description, print, readFn, writeFn, walkFn) {
+	const patched = [];
+	for (const filepath of walkFn(dir)) {
+		let content;
+		try {
+			content = readFn(filepath);
+		} catch {
+			continue;
+		}
+		if (isBinary(content)) continue;
+		const original = content;
+		for (const [search, replacement] of variants) content = content.split(search).join(replacement);
+		if (description !== void 0) content = content.split("<description>").join(description);
+		if (content !== original) {
+			writeFn(filepath, content);
+			print(`  ✓ ${path.relative(dir, filepath)}`);
+			patched.push(filepath);
+		}
+	}
+	return patched;
+}
+function preflight$1() {
+	const result = spawnSync("gh", ["--version"], { encoding: "utf8" });
+	if (result.error != null || result.status !== 0) throw new NewError("`gh` CLI is not installed or not on PATH. Install it from https://cli.github.com");
+}
+function defaultExec$3(cmd, args, opts) {
+	execFileSync(cmd, args, {
+		cwd: opts.cwd,
+		stdio: opts.stdio
+	});
+}
+function defaultReadFile(filepath) {
+	return readFileSync(filepath, "utf-8");
+}
+function defaultWriteFile(filepath, content) {
+	mkdirSync(path.dirname(filepath), { recursive: true });
+	writeFileSync(filepath, content, "utf-8");
+}
+async function runNew(input) {
+	const cwd = input.cwd ?? process.cwd();
+	const org = input.org ?? "theholocron";
+	const print = input.print ?? ((line) => console.log(line));
+	const execFn = input.exec ?? defaultExec$3;
+	const readFn = input.readFile ?? defaultReadFile;
+	const writeFn = input.writeFile ?? defaultWriteFile;
+	const walkFn = input.walkFiles ?? defaultWalkFiles$1;
+	preflight$1();
+	const templateRepo = `${org}/${input.type}-template`;
+	const newRepo = `${org}/${input.name}`;
+	const repoDir = path.join(cwd, input.name);
+	if (input.dryRun) {
+		print(`  Would create ${newRepo} from template ${templateRepo}`);
+		print(`  Would clone to ${repoDir}`);
+		print(`  Would patch all casing variants of "${input.type}-template" → "${input.name}"`);
+		if (input.description) print(`  Would replace <description> → "${input.description}"`);
+		return { status: "dry-run" };
+	}
+	if (existsSync(repoDir)) throw new NewError(`\`${repoDir}\` already exists — delete it or pick a different name.`);
+	print(`  Creating ${newRepo} from template ${templateRepo}…`);
+	try {
+		execFn("gh", [
+			"repo",
+			"create",
+			newRepo,
+			`--template=${templateRepo}`,
+			"--private",
+			"--clone"
+		], {
+			cwd,
+			stdio: "inherit"
+		});
+	} catch (err) {
+		throw new NewError(`gh repo create failed: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	let templateSlug = `${input.type}-template`;
+	const pkgJsonPath = path.join(repoDir, "package.json");
+	if (existsSync(pkgJsonPath)) try {
+		const pkg = JSON.parse(readFn(pkgJsonPath));
+		if (typeof pkg.name === "string") templateSlug = pkg.name.split("/").pop() ?? templateSlug;
+	} catch {}
+	print(`  Detected template slug: ${templateSlug}`);
+	print(`  Patching files…`);
+	const filesPatched = patchFiles(repoDir, deriveVariants(templateSlug, input.name), input.description, print, readFn, writeFn, walkFn);
+	print(`  ${filesPatched.length} file${filesPatched.length === 1 ? "" : "s"} patched`);
+	if (filesPatched.length > 0) {
+		execFn("git", ["add", "-A"], {
+			cwd: repoDir,
+			stdio: "inherit"
+		});
+		execFn("git", [
+			"commit",
+			"-s",
+			"-m",
+			`chore: bootstrap from ${templateSlug}`
+		], {
+			cwd: repoDir,
+			stdio: "inherit"
+		});
+	}
+	if (!input.noVerify) {
+		print("");
+		print("  Installing dependencies…");
+		try {
+			execFn("pnpm", ["install"], {
+				cwd: repoDir,
+				stdio: "inherit"
+			});
+		} catch (err) {
+			print(`  ✗ pnpm install failed — ${err instanceof Error ? err.message : String(err)}`);
+			return {
+				status: "fail",
+				repoDir,
+				filesPatched,
+				message: "pnpm install failed; inspect output above"
+			};
+		}
+	}
+	print("");
+	print(`  Scaffolded ${newRepo} (${filesPatched.length} file${filesPatched.length === 1 ? "" : "s"} patched).`);
+	print("");
+	print("  Next:");
+	print(`    1. cd ${repoDir}`);
+	if (input.noVerify) print(`    2. pnpm install`);
+	const step = input.noVerify ? 3 : 2;
+	print(`    ${step}. holocron setup  # wire up secrets, teams, labels, etc.`);
+	print(`    ${step + 1}. git push -u origin HEAD`);
+	return {
+		status: "ok",
+		repoDir,
+		filesPatched
+	};
+}
+//#endregion
 //#region src/loader.ts
 var LoaderError = class extends Error {
 	name = "LoaderError";
@@ -1438,7 +1642,6 @@ async function runNpmPublishInitial(input = {}) {
 	const publishArgs = [
 		"-r",
 		"--filter=./packages/*",
-		"--filter=!@theholocron/cli-utils",
 		"publish",
 		"--access",
 		"public",
@@ -4488,6 +4691,72 @@ await yargs(hideBin(process.argv)).scriptName("holocron").usage("$0 <command> [o
 }).command("config show", "Print the resolved holocron config", () => {}, async (argv) => {
 	const loaded = await loadConfig(argv.cwd);
 	console.log(JSON.stringify(loaded.resolved, null, 2));
+}).command("new [type] [name]", "Scaffold a new repo from a GitHub template (e.g. cli, react, nextjs, node, monorepo, base)", (y) => y.positional("type", {
+	type: "string",
+	describe: "Template type — maps to theholocron/<type>-template (e.g. cli, react, nextjs, node, monorepo, base)"
+}).positional("name", {
+	type: "string",
+	describe: "New repo name (kebab-case, e.g. my-tool)"
+}).option("description", {
+	type: "string",
+	describe: "Short description — replaces <description> placeholders in the template"
+}).option("org", {
+	type: "string",
+	default: "theholocron",
+	describe: "GitHub org that owns the template and will own the new repo"
+}).option("verify", {
+	type: "boolean",
+	default: true,
+	describe: "Run pnpm install after bootstrapping (default true; --no-verify skips)"
+}), async (argv) => {
+	try {
+		let type = argv.type;
+		let name = argv.name;
+		let description = argv.description;
+		if (!type || !name || description === void 0) {
+			const rl = createInterface({
+				input: stdin,
+				output: stdout
+			});
+			const ask = (question) => new Promise((resolve) => rl.question(`  ${question} `, (answer) => resolve(answer.trim())));
+			try {
+				if (!type) {
+					console.log("  Known types: base, cli, monorepo, nextjs, node, react");
+					type = await ask("Template type:");
+				}
+				if (!name) name = await ask("Repo name (kebab-case):");
+				if (description === void 0) description = await ask("Short description (Enter to skip):");
+			} finally {
+				rl.close();
+			}
+		}
+		if (!type) {
+			console.error("new: template type is required");
+			process.exitCode = 1;
+			return;
+		}
+		if (!name) {
+			console.error("new: repo name is required");
+			process.exitCode = 1;
+			return;
+		}
+		if ((await runNew({
+			type,
+			name,
+			...description ? { description } : {},
+			org: argv.org,
+			dryRun: argv.dryRun,
+			noVerify: !argv.verify,
+			cwd: argv.cwd
+		})).status === "fail") process.exitCode = 1;
+	} catch (err) {
+		if (err instanceof NewError) {
+			console.error(`new: ${err.message}`);
+			process.exitCode = 1;
+			return;
+		}
+		throw err;
+	}
 }).command("plugin create <slug> <vendor>", "Scaffold a new @theholocron/holocron-plugin-<slug> package", (y) => y.positional("slug", {
 	type: "string",
 	demandOption: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theholocron/cli",
-  "version": "2.0.0-alpha.76",
+  "version": "2.0.0-alpha.77",
   "description": "The Holocron CLI — a pluggable, capability-based orchestrator for spinning up and operating software projects.",
   "homepage": "https://github.com/theholocron/holocron/tree/main/packages/cli#readme",
   "bugs": "https://github.com/theholocron/holocron/issues",
@@ -54,8 +54,7 @@
     "globals": "^17.7.0",
     "tsdown": "^0.22.3",
     "typescript": "^5.9.3",
-    "vitest": "^4.1.10",
-    "@theholocron/cli-utils": "0.0.0"
+    "vitest": "^4.1.10"
   },
   "publishConfig": {
     "access": "public"