mick-templates 1.1.4 → 1.1.6

package/bin/cli.js

@@ -2,6 +2,8 @@
 import { spawn } from "child_process";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
+import { createRequire } from "module";
+import { getUserAgent } from "package-manager-detector";
 
 // Get the directory where this script is located
 const __filename = fileURLToPath(import.meta.url);
@@ -9,8 +11,32 @@ const binDir = dirname(__filename);
 const projectRoot = join(binDir, "..");
 const cliPath = join(projectRoot, "src", "index.tsx");
 
-// Use npx to run tsx (it will find tsx from the package dependencies)
-const child = spawn("npx", ["tsx", cliPath, ...process.argv.slice(2)], {
+// Detect the package manager agent
+const agent = getUserAgent() ?? "npm";
+
+let command;
+let args;
+
+if (agent === "bun") {
+  command = "bun";
+  args = [cliPath, ...process.argv.slice(2)];
+} else {
+  const require = createRequire(import.meta.url);
+  try {
+    // Try to resolve tsx from the package's dependencies
+    const tsxPath = require.resolve("tsx/cli");
+    command = process.execPath || "node";
+    args = [tsxPath, cliPath, ...process.argv.slice(2)];
+  } catch (_err) {
+    // Fallback to npx if tsx is not resolvable
+    const isWin = process.platform === "win32";
+    command = isWin ? "npx.cmd" : "npx";
+    args = ["tsx", cliPath, ...process.argv.slice(2)];
+  }
+}
+
+// Spawn the command
+const child = spawn(command, args, {
   stdio: "inherit",
   cwd: process.cwd(),
   env: process.env,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mick-templates",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "CLI tool for creating projects from templates",
   "bin": {
     "mick-templates": "bin/cli.js"

package/src/lib/pm.ts

@@ -1,13 +1,15 @@
 import { getUserAgent, resolveCommand } from "package-manager-detector";
 import type { AgentName } from "package-manager-detector";
 import { spawn } from "child_process";
+import { createRequire } from "module";
+import { join, dirname } from "path";
+import { readFile } from "fs/promises";
 
 /**
  * Get the current package manager agent.
  */
 export function getAgent(): AgentName {
-  const ua = getUserAgent();
-  return ua?.name ?? "npm";
+  return getUserAgent() ?? "npm";
 }
 
 /**
@@ -16,7 +18,9 @@ export function getAgent(): AgentName {
 function run(cmd: string, args: string[], cwd: string): Promise<void> {
   return new Promise((resolve, reject) => {
     spawn(cmd, args, { cwd, stdio: "inherit" })
-      .on("close", (code) => (code === 0 ? resolve() : reject(new Error(`Exit ${code}`))))
+      .on("close", (code) =>
+        code === 0 ? resolve() : reject(new Error(`Exit ${code}`))
+      )
       .on("error", reject);
   });
 }
@@ -28,17 +32,51 @@ export async function install(cwd: string): Promise<void> {
   const agent = getAgent();
   const resolved = resolveCommand(agent, "install", []);
   if (!resolved) throw new Error(`Cannot resolve install command for ${agent}`);
-  
+
   await run(resolved.command, resolved.args, cwd);
 }
 
 /**
  * Execute a package binary (npx/bunx/etc).
  */
-export async function execute(cwd: string, pkg: string, args: string[]): Promise<void> {
+export async function execute(
+  cwd: string,
+  pkg: string,
+  args: string[]
+): Promise<void> {
   const agent = getAgent();
+
+  if (agent === "bun") {
+    await run("bunx", [pkg, ...args], cwd);
+    return;
+  }
+
+  // Try to resolve the package binary from our own dependencies
+  try {
+    const require = createRequire(import.meta.url);
+    const pkgJsonPath = require.resolve(`${pkg}/package.json`);
+    const pkgJson = JSON.parse(await readFile(pkgJsonPath, "utf-8")) as Record<
+      string,
+      any
+    >;
+
+    let binPath: string | undefined;
+    if (typeof pkgJson.bin === "string") {
+      binPath = join(dirname(pkgJsonPath), pkgJson.bin);
+    } else if (pkgJson.bin && pkgJson.bin[pkg]) {
+      binPath = join(dirname(pkgJsonPath), pkgJson.bin[pkg]);
+    }
+
+    if (binPath) {
+      await run("node", [binPath, ...args], cwd);
+      return;
+    }
+  } catch (_err) {
+    // Fallback to global execute
+  }
+
   const resolved = resolveCommand(agent, "execute", [pkg, ...args]);
   if (!resolved) throw new Error(`Cannot resolve execute command for ${agent}`);
-  
+
   await run(resolved.command, resolved.args, cwd);
 }