create-obsidian-arrow 0.5.1 → 0.5.2

package/README.md

@@ -42,9 +42,9 @@ scaffold folder (the CLI is cwd-relative); use `--project-dir=<outer-repo>` (or
 `--global`) to install where an agent at the outer repo looks. The scaffolder
 prints this hint when it detects nesting.
 
-## Update an existing project
+## Refresh an existing project
 
-The scaffolder is create-only, but `update` refreshes an existing project's
+The scaffolder is create-first, but `refresh` refreshes an existing project's
 **managed** files (`scripts/`, `docs/`, `.github/`, `.husky/`, `biome.json`,
 agent guides, `tools/viewer/`, `tools/router/`, `tools/sandbox/`, `src/main.ts`,
 `src/utilities.css`, `test/`) and merges new `package.json` scripts/deps —
@@ -52,19 +52,19 @@ it never touches `src/components/`, `stories/`, `public/`, `index.html`, or
 build configs:
 
 ```sh
-npx create-obsidian-arrow update            # in the project (or: update <dir>)
-npx create-obsidian-arrow update --dry-run  # preview
+npx create-obsidian-arrow refresh            # in the project (or: refresh <dir>)
+npx create-obsidian-arrow refresh --dry-run  # preview
 ```
 
-Then `pnpm install && pnpm check`.
+Then install with your package manager and run the `check` script.
 
 ## Local dev of the initializer
 
 From the sandbox repo, before publishing:
 
 ```sh
-node create-obsidian-arrow/index.mjs ../my-app          # scaffold
-node create-obsidian-arrow/index.mjs update ../my-app   # update
+node create-obsidian-arrow/index.mjs create ../my-app    # scaffold
+node create-obsidian-arrow/index.mjs refresh ../my-app   # refresh
 ```
 
 ## What you get

package/cli/create.mjs

@@ -0,0 +1,65 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import { copyTree, ensureTemplate, fail, outerRepoAbove, templateDir } from "./lib.mjs";
+
+/**
+ * Scaffold a new project into `targetArg`.
+ *
+ * Copies the vendored template/, restores .gitignore (vendored as _gitignore),
+ * names the project after the target dir, and runs `git init`.
+ */
+export function create(targetArg, opts = {}) {
+	ensureTemplate();
+	const destRoot = path.resolve(process.cwd(), targetArg);
+	const appName = path.basename(destRoot);
+
+	if (fs.existsSync(destRoot) && fs.readdirSync(destRoot).length > 0) {
+		fail(`target "${targetArg}" already exists and is not empty (use \`refresh\` to refresh it).`);
+	}
+
+	const written = [];
+	copyTree(templateDir, destRoot, destRoot, written, false);
+	// Restore .gitignore (npm omits .gitignore from packages; vendored as _gitignore).
+	const vendoredIgnore = path.join(destRoot, "_gitignore");
+	if (fs.existsSync(vendoredIgnore)) {
+		fs.renameSync(vendoredIgnore, path.join(destRoot, ".gitignore"));
+	}
+
+	// Personalize the project name via targeted replace (keeps Biome formatting).
+	const pkgPath = path.join(destRoot, "package.json");
+	const renamed = fs
+		.readFileSync(pkgPath, "utf8")
+		.replace(/("name":\s*)"[^"]*"/, (_m, prefix) => `${prefix}${JSON.stringify(appName)}`);
+	fs.writeFileSync(pkgPath, renamed);
+
+	spawnSync("git", ["init", "-q"], { cwd: destRoot, stdio: "ignore" });
+
+	if (opts.json) {
+		process.stdout.write(
+			`${JSON.stringify({ action: "create", dir: destRoot, written, pkgChanges: [`name: ${appName}`] })}\n`
+		);
+		return;
+	}
+
+	console.log(
+		`\n${chalk.green("Scaffolded")} ${chalk.bold(appName)} in ${path.relative(process.cwd(), destRoot) || "."}\n`
+	);
+	// A fresh scaffold has no lockfile yet — stay package-manager-neutral.
+	console.log("Next steps:");
+	console.log(chalk.cyan(`  cd ${targetArg}`));
+	console.log(`  ${chalk.dim("# install with your package manager (pnpm / npm / bun / yarn)")}`);
+	console.log(chalk.cyan("  <pm> install"));
+	console.log(
+		`  ${chalk.cyan("<pm> run pull-css")}   ${chalk.dim("# extract Obsidian's app.css (macOS auto-detect)")}`
+	);
+	console.log(chalk.cyan("  <pm> run dev\n"));
+
+	const outer = outerRepoAbove(destRoot);
+	if (outer) {
+		console.log(chalk.yellow(`Note: this project is nested inside the repo at ${outer}.`));
+		console.log("  Bundled skills install scoped to THIS project. To install them at the");
+		console.log(`  outer repo instead:  <pm> run skills:install -- --yes --project-dir=${outer}\n`);
+	}
+}

package/cli/detect-pm.mjs

@@ -0,0 +1,20 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const LOCK = [
+	["bun.lockb", "bun"],
+	["pnpm-lock.yaml", "pnpm"],
+	["yarn.lock", "yarn"],
+	["package-lock.json", "npm"],
+];
+
+/** Detect the package manager governing `dir` from its lockfile.
+ * Falls back to npm. `exec` is the argv prefix for running a script. */
+export function detectPM(dir = process.cwd()) {
+	for (const [f, name] of LOCK) {
+		if (fs.existsSync(path.join(dir, f))) {
+			return { name, exec: name === "yarn" ? ["yarn"] : [name, "run"] };
+		}
+	}
+	return { name: "npm", exec: ["npm", "run"] };
+}

package/cli/lib.mjs

@@ -0,0 +1,117 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url)); // cli/
+export const pkgRoot = path.resolve(here, ".."); // packages/create-obsidian-arrow
+export const templateDir = path.join(pkgRoot, "template");
+
+// Files/dirs the template owns and `refresh` may overwrite/merge.
+//
+// src/components/ and stories/ are user-owned and never touched.
+// tools/ contains all viewer/router/sandbox infrastructure and IS managed.
+// Everything else (public/, index.html, vite.config.ts, tsconfig.json,
+// lockfile, .gitignore, port-parity.json, …) is also user-owned.
+export const MANAGED = [
+	// Tooling
+	"scripts",
+	"docs",
+	".github",
+	".husky",
+	"biome.json",
+	"AGENTS.md",
+	"CLAUDE.md",
+	// Viewer infrastructure — all managed; src/components/ and stories/ are user-owned
+	"tools",
+	"src/main.ts",
+	"src/utilities.css",
+	// Viewer tests
+	"test",
+];
+
+export function fail(message) {
+	console.error(`create-obsidian-arrow: ${message}`);
+	process.exit(1);
+}
+
+export function ensureTemplate() {
+	if (!fs.existsSync(templateDir)) {
+		fail("template/ is missing — run scripts/sync-template.mjs to build it.");
+	}
+}
+
+/** Nearest ancestor *above* `dir` that is a git repo, or null. */
+export function outerRepoAbove(dir) {
+	let current = path.dirname(path.resolve(dir));
+	const fsRoot = path.parse(current).root;
+	while (current && current !== fsRoot) {
+		if (fs.existsSync(path.join(current, ".git"))) {
+			return current;
+		}
+		current = path.dirname(current);
+	}
+	return null;
+}
+
+/** Recursively copy src→dest; returns the list of written file paths (relative
+ * to `base`). Honors `dryRun` (records but doesn't write). */
+export function copyTree(src, dest, base, written, dryRun) {
+	const stat = fs.statSync(src);
+	if (stat.isDirectory()) {
+		if (!dryRun) {
+			fs.mkdirSync(dest, { recursive: true });
+		}
+		for (const entry of fs.readdirSync(src)) {
+			copyTree(path.join(src, entry), path.join(dest, entry), base, written, dryRun);
+		}
+		return;
+	}
+	written.push(path.relative(base, dest));
+	if (!dryRun) {
+		fs.mkdirSync(path.dirname(dest), { recursive: true });
+		fs.copyFileSync(src, dest);
+	}
+}
+
+/** Merge template package.json scripts + missing deps into the target's,
+ * preserving name/version/identity and existing dep versions. Returns the
+ * list of change descriptions.
+ *
+ * Also propagates top-level `lint-staged` and `pnpm` fields when absent in
+ * the target so refreshed old projects get husky/lint-staged fully wired. */
+export function mergePackageJson(targetPkgPath, dryRun) {
+	const tpl = JSON.parse(fs.readFileSync(path.join(templateDir, "package.json"), "utf8"));
+	const pkg = JSON.parse(fs.readFileSync(targetPkgPath, "utf8"));
+	const changes = [];
+
+	pkg.scripts ??= {};
+	for (const [name, cmd] of Object.entries(tpl.scripts ?? {})) {
+		if (pkg.scripts[name] !== cmd) {
+			changes.push(`script ${name}`);
+			pkg.scripts[name] = cmd;
+		}
+	}
+	for (const field of ["dependencies", "devDependencies"]) {
+		pkg[field] ??= {};
+		for (const [name, version] of Object.entries(tpl[field] ?? {})) {
+			if (!(name in pkg[field])) {
+				changes.push(`${field}: ${name}`);
+				pkg[field][name] = version;
+			}
+		}
+	}
+
+	// Propagate top-level lint-staged and pnpm fields when absent (so refreshed
+	// old projects get husky/lint-staged fully configured, not just the devDeps).
+	for (const field of ["lint-staged", "pnpm"]) {
+		if (tpl[field] !== undefined && pkg[field] === undefined) {
+			changes.push(field);
+			pkg[field] = tpl[field];
+		}
+	}
+
+	if (changes.length > 0 && !dryRun) {
+		fs.writeFileSync(targetPkgPath, `${JSON.stringify(pkg, null, "\t")}\n`);
+	}
+	return changes;
+}

package/cli/refresh.mjs

@@ -0,0 +1,65 @@
+import fs from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import { detectPM } from "./detect-pm.mjs";
+import { MANAGED, copyTree, ensureTemplate, fail, mergePackageJson, templateDir } from "./lib.mjs";
+
+/**
+ * Refresh an existing project's *managed* files from the template and merge
+ * package.json scripts + missing deps. Preserves user code. `--dry-run` first.
+ */
+export function refresh(targetArg, opts = {}) {
+	ensureTemplate();
+	const dryRun = Boolean(opts.dryRun);
+	const root = path.resolve(process.cwd(), targetArg ?? ".");
+	if (!fs.existsSync(path.join(root, "package.json"))) {
+		fail(`no package.json in ${root} — is this a scaffolded project?`);
+	}
+
+	const written = [];
+	for (const name of MANAGED) {
+		const src = path.join(templateDir, name);
+		if (fs.existsSync(src)) {
+			copyTree(src, path.join(root, name), root, written, dryRun);
+		}
+	}
+	const pkgChanges = mergePackageJson(path.join(root, "package.json"), dryRun);
+
+	// Create stories/ if missing — user-owned (never overwritten), but must
+	// exist before the first story file can be added.
+	const storiesDir = path.join(root, "stories");
+	const storiesCreated = !fs.existsSync(storiesDir);
+	if (storiesCreated && !dryRun) {
+		fs.mkdirSync(storiesDir);
+	}
+
+	if (opts.json) {
+		process.stdout.write(
+			`${JSON.stringify({ action: "refresh", dir: root, written, pkgChanges })}\n`
+		);
+		return;
+	}
+
+	const pm = detectPM(root);
+	const run = pm.exec.join(" ");
+	const verb = dryRun ? "Would refresh" : "Refreshed";
+	console.log(
+		`${chalk.green(verb)} ${written.length} managed file(s) in ${path.relative(process.cwd(), root) || "."}:`
+	);
+	for (const file of written) {
+		console.log(`  ${file}`);
+	}
+	if (storiesCreated) {
+		console.log(
+			`  stories/  ${dryRun ? "(would create empty)" : "(created empty — add your *.stories.ts files here)"}`
+		);
+	}
+	if (pkgChanges.length > 0) {
+		console.log(`package.json: ${dryRun ? "would update" : "updated"} ${pkgChanges.join(", ")}`);
+	}
+	console.log(
+		dryRun
+			? "\n(dry run — nothing written.)"
+			: `\nLeft alone: src/components/, stories/, public/, index.html, vite.config.ts, tsconfig.json, .gitignore.\n(tools/, src/main.ts, src/utilities.css, and test/ were refreshed above.)\nRun \`${pm.name} install\` then \`${run} check\`. Update skills separately with \`${run} skills:update\`.\n`
+	);
+}

package/index.mjs

@@ -1,221 +1,64 @@
 #!/usr/bin/env node
 /**
- * create-obsidian-arrow — scaffold or update an Obsidian-styled Arrow.js sandbox.
+ * create-obsidian-arrow — scaffold or refresh an Obsidian-styled Arrow.js sandbox.
  *
- *   create-obsidian-arrow <dir>            scaffold a new project into <dir>
- *   create-obsidian-arrow update [dir]     refresh an existing project's tooling
- *                                          (default dir: cwd) — preserves your code
+ *   create-obsidian-arrow create <dir>       scaffold a new project into <dir>
+ *   create-obsidian-arrow refresh [dir]      refresh an existing project's tooling
+ *                                            (default dir: cwd) — preserves your code
+ *   create-obsidian-arrow <dir>              bare-arg shorthand for `create <dir>`
  *
  *   pnpm create obsidian-arrow my-app
- *   node create-obsidian-arrow/index.mjs my-app          # locally
- *   node create-obsidian-arrow/index.mjs update ./my-app
+ *   npx create-obsidian-arrow my-app
  *
- * Scaffold copies the vendored template/, restores .gitignore (vendored as
+ * `create` copies the vendored template/, restores .gitignore (vendored as
  * _gitignore), names the project, and runs `git init`.
  *
- * Update refreshes *managed* files from the template and merges package.json
+ * `refresh` refreshes *managed* files from the template and merges package.json
  * scripts + missing deps. Managed = scripts/, docs/, .github/, .husky/,
  * biome.json, AGENTS.md, CLAUDE.md, tools/, src/main.ts, src/utilities.css,
  * test/. Never touches src/components/, stories/, public/, index.html,
  * vite.config.ts, tsconfig.json, or .gitignore. Use --dry-run first.
  */
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const here = path.dirname(fileURLToPath(import.meta.url));
-const templateDir = path.join(here, "template");
-
-// Files/dirs the template owns and `update` may overwrite/merge.
-//
-// src/components/ and stories/ are user-owned and never touched.
-// tools/ contains all viewer/router/sandbox infrastructure and IS managed.
-// Everything else (public/, index.html, vite.config.ts, tsconfig.json,
-// lockfile, .gitignore, port-parity.json, …) is also user-owned. Skills aren't here — they're pulled from the published
-// repo via `pnpm skills:update`, not vendored into the scaffold.
-const MANAGED = [
-	// Tooling
-	"scripts",
-	"docs",
-	".github",
-	".husky",
-	"biome.json",
-	"AGENTS.md",
-	"CLAUDE.md",
-	// Viewer infrastructure — all managed; src/components/ and stories/ are user-owned
-	"tools",
-	"src/main.ts",
-	"src/utilities.css",
-	// Viewer tests
-	"test",
-];
-
+import { Command } from "commander";
+import { create } from "./cli/create.mjs";
+import { refresh } from "./cli/refresh.mjs";
+
+const program = new Command();
+
+program
+	.name("create-obsidian-arrow")
+	.description("Scaffold or refresh an Obsidian-styled Arrow.js UI sandbox.");
+
+program
+	.command("create")
+	.argument("<dir>", "directory to scaffold into")
+	.description("scaffold a new project into <dir>")
+	.option("--json", "emit a single JSON line describing the result")
+	.allowExcessArguments(false)
+	.action((dir, opts) => create(dir, opts));
+
+program
+	.command("refresh")
+	.argument("[dir]", "project directory (default: cwd)")
+	.description("refresh an existing project's managed tooling")
+	.option("--dry-run", "list what would change without writing")
+	.option("--json", "emit a single JSON line describing the result")
+	.allowExcessArguments(false)
+	.action((dir, opts) => refresh(dir, opts));
+
+// Bare-arg shorthand: `create-obsidian-arrow my-app` → `create my-app`, so
+// `npx create-obsidian-arrow my-app` still works. If the first non-option token
+// isn't a known subcommand, prepend `create` at the FRONT so any leading global
+// flags (e.g. `--json my-app`) attach to the `create` subcommand rather than the
+// (option-less) root program.
 const argv = process.argv.slice(2);
-const dryRun = argv.includes("--dry-run");
-
-function fail(message) {
-	console.error(`create-obsidian-arrow: ${message}`);
-	process.exit(1);
-}
-
-if (!fs.existsSync(templateDir)) {
-	fail("template/ is missing — run scripts/sync-template.mjs to build it.");
-}
-
-/** Nearest ancestor *above* `dir` that is a git repo, or null. */
-function outerRepoAbove(dir) {
-	let current = path.dirname(path.resolve(dir));
-	const fsRoot = path.parse(current).root;
-	while (current && current !== fsRoot) {
-		if (fs.existsSync(path.join(current, ".git"))) {
-			return current;
-		}
-		current = path.dirname(current);
-	}
-	return null;
+const firstToken = argv.find((a) => !a.startsWith("-"));
+const knownCommands = new Set(["create", "refresh", "help"]);
+if (firstToken && !knownCommands.has(firstToken)) {
+	argv.unshift("create");
 }
-
-/** Recursively copy src→dest; returns the list of written file paths (relative
- * to `base`). Honors --dry-run (records but doesn't write). */
-function copyTree(src, dest, base, written) {
-	const stat = fs.statSync(src);
-	if (stat.isDirectory()) {
-		if (!dryRun) {
-			fs.mkdirSync(dest, { recursive: true });
-		}
-		for (const entry of fs.readdirSync(src)) {
-			copyTree(path.join(src, entry), path.join(dest, entry), base, written);
-		}
-		return;
-	}
-	written.push(path.relative(base, dest));
-	if (!dryRun) {
-		fs.mkdirSync(path.dirname(dest), { recursive: true });
-		fs.copyFileSync(src, dest);
-	}
+if (argv.length === 0) {
+	program.help();
 }
 
-function scaffold(targetArg) {
-	const destRoot = path.resolve(process.cwd(), targetArg);
-	const appName = path.basename(destRoot);
-
-	if (fs.existsSync(destRoot) && fs.readdirSync(destRoot).length > 0) {
-		fail(`target "${targetArg}" already exists and is not empty (use \`update\` to refresh it).`);
-	}
-
-	const written = [];
-	copyTree(templateDir, destRoot, destRoot, written);
-	// Restore .gitignore (npm omits .gitignore from packages; vendored as _gitignore).
-	const vendoredIgnore = path.join(destRoot, "_gitignore");
-	if (fs.existsSync(vendoredIgnore)) {
-		fs.renameSync(vendoredIgnore, path.join(destRoot, ".gitignore"));
-	}
-
-	// Personalize the project name via targeted replace (keeps Biome formatting).
-	const pkgPath = path.join(destRoot, "package.json");
-	const renamed = fs
-		.readFileSync(pkgPath, "utf8")
-		.replace(/("name":\s*)"[^"]*"/, (_m, prefix) => `${prefix}${JSON.stringify(appName)}`);
-	fs.writeFileSync(pkgPath, renamed);
-
-	spawnSync("git", ["init", "-q"], { cwd: destRoot, stdio: "ignore" });
-
-	console.log(`\nScaffolded ${appName} in ${path.relative(process.cwd(), destRoot) || "."}\n`);
-	console.log("Next steps:");
-	console.log(`  cd ${targetArg}`);
-	console.log("  pnpm install");
-	console.log("  pnpm pull-css     # extract Obsidian's app.css (macOS auto-detect)");
-	console.log("  pnpm dev\n");
-
-	const outer = outerRepoAbove(destRoot);
-	if (outer) {
-		console.log(`Note: this project is nested inside the repo at ${outer}.`);
-		console.log("  Bundled skills install scoped to THIS project. To install them at the");
-		console.log(`  outer repo instead:  pnpm skills:install --yes --project-dir=${outer}\n`);
-	}
-}
-
-/** Merge template package.json scripts + missing deps into the target's,
- * preserving name/version/identity and existing dep versions. */
-function mergePackageJson(targetPkgPath) {
-	const tpl = JSON.parse(fs.readFileSync(path.join(templateDir, "package.json"), "utf8"));
-	const pkg = JSON.parse(fs.readFileSync(targetPkgPath, "utf8"));
-	const changes = [];
-
-	pkg.scripts ??= {};
-	for (const [name, cmd] of Object.entries(tpl.scripts ?? {})) {
-		if (pkg.scripts[name] !== cmd) {
-			changes.push(`script ${name}`);
-			pkg.scripts[name] = cmd;
-		}
-	}
-	for (const field of ["dependencies", "devDependencies"]) {
-		pkg[field] ??= {};
-		for (const [name, version] of Object.entries(tpl[field] ?? {})) {
-			if (!(name in pkg[field])) {
-				changes.push(`${field}: ${name}`);
-				pkg[field][name] = version;
-			}
-		}
-	}
-
-	if (changes.length > 0 && !dryRun) {
-		fs.writeFileSync(targetPkgPath, `${JSON.stringify(pkg, null, "\t")}\n`);
-	}
-	return changes;
-}
-
-function update(targetArg) {
-	const root = path.resolve(process.cwd(), targetArg ?? ".");
-	if (!fs.existsSync(path.join(root, "package.json"))) {
-		fail(`no package.json in ${root} — is this a scaffolded project?`);
-	}
-
-	const written = [];
-	for (const name of MANAGED) {
-		const src = path.join(templateDir, name);
-		if (fs.existsSync(src)) {
-			copyTree(src, path.join(root, name), root, written);
-		}
-	}
-	const pkgChanges = mergePackageJson(path.join(root, "package.json"));
-
-	// Create stories/ if missing — user-owned (never overwritten), but must
-	// exist before the first story file can be added.
-	const storiesDir = path.join(root, "stories");
-	const storiesCreated = !fs.existsSync(storiesDir);
-	if (storiesCreated && !dryRun) {
-		fs.mkdirSync(storiesDir);
-	}
-
-	const verb = dryRun ? "Would refresh" : "Refreshed";
-	console.log(
-		`${verb} ${written.length} managed file(s) in ${path.relative(process.cwd(), root) || "."}:`
-	);
-	for (const file of written) {
-		console.log(`  ${file}`);
-	}
-	if (storiesCreated) {
-		console.log(
-			`  stories/  ${dryRun ? "(would create empty)" : "(created empty — add your *.stories.ts files here)"}`
-		);
-	}
-	if (pkgChanges.length > 0) {
-		console.log(`package.json: ${dryRun ? "would update" : "updated"} ${pkgChanges.join(", ")}`);
-	}
-	console.log(
-		dryRun
-			? "\n(dry run — nothing written.)"
-			: "\nLeft alone: src/components/, stories/, public/, index.html, vite.config.ts, tsconfig.json, .gitignore.\n(tools/, src/main.ts, src/utilities.css, and test/ were refreshed above.)\nRun `pnpm install` then `pnpm check`. Update skills separately with `pnpm skills:update`.\n"
-	);
-}
-
-const command = argv[0];
-if (command === "update") {
-	update(argv.find((a) => a !== "update" && !a.startsWith("--")));
-} else if (!command || command.startsWith("--")) {
-	fail("usage: create-obsidian-arrow <directory> | update [directory]");
-} else {
-	scaffold(command);
-}
+program.parse(argv, { from: "user" });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-obsidian-arrow",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Scaffold an Obsidian-styled Arrow.js UI sandbox (pnpm create obsidian-arrow <dir>).",
   "type": "module",
   "bin": {
@@ -8,6 +8,7 @@
   },
   "files": [
     "index.mjs",
+    "cli",
     "template"
   ],
   "engines": {
@@ -36,5 +37,13 @@
     "url": "git+https://github.com/kylebrodeur/obsidian-arrow-sandbox.git",
     "directory": "create-obsidian-arrow"
   },
-  "scripts": {}
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^12.1.0"
+  },
+  "scripts": {
+    "test": "node --test test/**/*.test.mjs",
+    "check": "node --test test/**/*.test.mjs",
+    "ci": "node --test test/**/*.test.mjs"
+  }
 }

package/template/.husky/pre-commit

@@ -1,2 +1,3 @@
-pnpm exec lint-staged
-pnpm typecheck
+#!/usr/bin/env sh
+./node_modules/.bin/lint-staged
+./node_modules/.bin/tsc -p tsconfig.json --noEmit