create-pylon 1.0.3 → 1.1.0

package/dist/index.js

@@ -3,17 +3,123 @@
 
 // src/index.ts
 import { Option, program } from "commander";
-import consola from "consola";
+import consola2 from "consola";
 import { input, select, confirm } from "@inquirer/prompts";
-import path from "path";
+import path2 from "path";
 import chalk from "chalk";
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as telemetry from "@getcronit/pylon-telemetry";
 import { fileURLToPath } from "url";
 import { dirname } from "path";
+import { spawnSync } from "child_process";
+
+// src/detect-pm.ts
+import * as fs from "fs";
+import * as path from "path";
+import process2 from "process";
+import { execSync } from "child_process";
+import consola from "consola";
+function isCommandAvailable(command) {
+  try {
+    execSync(`${command} --version`, { stdio: "ignore" });
+    return true;
+  } catch (e) {
+    console.error(e);
+    return false;
+  }
+}
+function isBun() {
+  return typeof Bun !== "undefined" && isCommandAvailable("bun");
+}
+function isNpm() {
+  return process2.env.npm_execpath?.includes("npm") ?? false;
+}
+function isYarn() {
+  return process2.env.npm_execpath?.includes("yarn") ?? false;
+}
+function isDeno() {
+  return typeof Deno !== "undefined" && isCommandAvailable("deno");
+}
+function isPnpm() {
+  return process2.env.npm_execpath?.includes("pnpm") ?? false;
+}
+function detectByLockFiles(cwd) {
+  if (fs.existsSync(path.join(cwd, "bun.lockb"))) {
+    return "bun";
+  }
+  if (fs.existsSync(path.join(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  if (fs.existsSync(path.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (fs.existsSync(path.join(cwd, "deno.json")) || fs.existsSync(path.join(cwd, "deno.lock"))) {
+    return "deno";
+  }
+  if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  return null;
+}
+function detectPackageManager({
+  preferredPm,
+  cwd = process2.cwd()
+}) {
+  if (preferredPm && isCommandAvailable(preferredPm)) {
+    return preferredPm;
+  }
+  if (isBun()) {
+    return "bun";
+  }
+  if (isNpm()) {
+    return "npm";
+  }
+  if (isPnpm()) {
+    return "pnpm";
+  }
+  if (isDeno()) {
+    return "deno";
+  }
+  if (isYarn()) {
+    return "yarn";
+  }
+  const lockFileDetection = detectByLockFiles(cwd);
+  if (lockFileDetection) {
+    consola.info(`Detected package manager by lock file: ${lockFileDetection}`);
+    if (isCommandAvailable(lockFileDetection)) {
+      return lockFileDetection;
+    } else {
+      consola.warn(`Lock file detected, but ${lockFileDetection} is not installed.`);
+    }
+  }
+  return "unknown";
+}
+function getRunScript(pm) {
+  switch (pm) {
+    case "bun":
+      return "bun";
+    case "npm":
+      return "npm run";
+    case "yarn":
+      return "yarn";
+    case "pnpm":
+      return "pnpm run";
+    case "deno":
+      return "deno task";
+    default:
+      throw new Error("Unknown package manager");
+  }
+}
+
+// src/index.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var version = (() => {
+  return JSON.parse(fs2.readFileSync(path2.join(__dirname2, "..", "package.json"), "utf-8")).version;
+})();
 function mkdirp(dir) {
   try {
-    fs.mkdirSync(dir, { recursive: true });
+    fs2.mkdirSync(dir, { recursive: true });
   } catch (e) {
     if (e instanceof Error) {
       if ("code" in e && e.code === "EEXIST")
@@ -22,11 +128,171 @@ function mkdirp(dir) {
     throw e;
   }
 }
-import { detect } from "detect-package-manager";
-import { spawnSync } from "child_process";
+var runtimes = [
+  {
+    key: "bun",
+    name: "Bun.js",
+    website: "https://bunjs.dev",
+    templates: ["default"]
+  },
+  {
+    key: "node",
+    name: "Node.js",
+    website: "https://nodejs.org",
+    templates: ["default"]
+  },
+  {
+    key: "cf-workers",
+    name: "Cloudflare Workers",
+    website: "https://workers.cloudflare.com",
+    templates: ["default"]
+  },
+  {
+    key: "deno",
+    name: "Deno",
+    website: "https://deno.land",
+    templates: ["default"]
+  }
+];
+var templates = [
+  {
+    key: "default",
+    name: "Default",
+    description: "Default template"
+  },
+  {
+    key: "database",
+    name: "Database (Prisma)",
+    description: "Template with Prisma ORM"
+  }
+];
+var injectVariablesInContent = (content, variables) => {
+  let result = content;
+  Object.entries(variables).forEach(([key, value]) => {
+    result = result.replaceAll(key, value);
+  });
+  return result;
+};
+var readdirFilesSyncRecursive = (dir) => {
+  const run = (dir2) => {
+    const result = [];
+    const files = fs2.readdirSync(dir2);
+    files.forEach((file) => {
+      const filePath = path2.join(dir2, file);
+      if (fs2.statSync(filePath).isDirectory()) {
+        result.push(...run(filePath));
+      }
+      if (fs2.statSync(filePath).isFile()) {
+        result.push(filePath);
+      }
+    });
+    return result;
+  };
+  return run(dir).map((file) => {
+    return file.replace(dir, ".");
+  });
+};
+var createTemplate = async (options) => {
+  const { runtime, template, target } = options;
+  const runtimeName = runtimes.find(({ key }) => key === runtime)?.name;
+  const templateName = templates.find(({ key }) => key === template)?.name;
+  if (!runtimeName) {
+    throw new Error(`Invalid runtime: ${runtime}`);
+  }
+  if (!templateName) {
+    throw new Error(`Invalid template: ${template}`);
+  }
+  const sharedTemplateDir = path2.join(__dirname2, "..", "templates", "shared");
+  if (!fs2.existsSync(sharedTemplateDir)) {
+    throw new Error(`Shared templates not found: ${sharedTemplateDir}`);
+  }
+  const templateDir = path2.join(__dirname2, "..", "templates", runtime, template);
+  if (!fs2.existsSync(templateDir)) {
+    throw new Error(`Template not found: ${templateDir}`);
+  }
+  const targetDirectoryPath = path2.join(process.cwd(), target);
+  consola2.start(`Creating pylon in ${targetDirectoryPath}`);
+  const inject = (content) => {
+    return injectVariablesInContent(content, {
+      __PYLON_NAME__: options.name
+    });
+  };
+  readdirFilesSyncRecursive(sharedTemplateDir).forEach((file) => {
+    const source = path2.join(sharedTemplateDir, file);
+    let target2 = path2.join(targetDirectoryPath, file);
+    const targetDir = path2.dirname(target2);
+    if (runtime === "cf-workers" && source.includes(".github/workflows/publish.yaml")) {
+      return;
+    }
+    if (!fs2.existsSync(targetDir)) {
+      fs2.mkdirSync(targetDir, { recursive: true });
+    }
+    if (target2.endsWith(".example")) {
+      target2 = target2.replace(".example", "");
+    }
+    const injectedContent = inject(fs2.readFileSync(source, "utf-8"));
+    fs2.writeFileSync(target2, injectedContent);
+  });
+  readdirFilesSyncRecursive(templateDir).forEach((file) => {
+    const source = path2.join(templateDir, file);
+    let target2 = path2.join(targetDirectoryPath, file);
+    const targetDir = path2.dirname(target2);
+    if (!fs2.existsSync(targetDir)) {
+      fs2.mkdirSync(targetDir, { recursive: true });
+    }
+    if (target2.endsWith(".example")) {
+      target2 = target2.replace(".example", "");
+    }
+    const injectedContent = inject(fs2.readFileSync(source, "utf-8"));
+    fs2.writeFileSync(target2, injectedContent);
+  });
+  consola2.success(`Pylon created`);
+};
+var installDependencies = async (args) => {
+  const target = path2.resolve(args.target);
+  const packageManager = args.packageManager;
+  let command = "";
+  switch (packageManager) {
+    case "yarn":
+      command = "yarn";
+      break;
+    case "npm":
+      command = "npm install";
+      break;
+    case "pnpm":
+      command = "pnpm install";
+      break;
+    case "bun":
+      command = "bun install";
+      break;
+    case "deno":
+      command = "deno install";
+      break;
+    default:
+      throw new Error(`Invalid package manager: ${packageManager}`);
+  }
+  consola2.start(`Installing dependencies using ${packageManager}`);
+  const proc = spawnSync(command, {
+    cwd: target,
+    shell: true,
+    stdio: "inherit"
+  });
+  if (proc.status !== 0) {
+    throw new Error(`Failed to install dependencies`);
+  }
+  consola2.success(`Dependencies installed`);
+};
+program.name("create-pylon").version(version).arguments("[target]").addOption(new Option("-i, --install", "Install dependencies")).addOption(new Option("-r, --runtime <runtime>", "Runtime").choices(runtimes.map(({ key }) => key))).addOption(new Option("-t, --template <template>", "Template")).addOption(new Option("-pm, --package-manager <packageManager>", "Package manager")).addOption(new Option("--client", "Enable client generation (https://pylon.cronit.io/docs/integrations/gqty)")).addOption(new Option("--client-path <clientPath>", "Client path")).addOption(new Option("--client-port <clientPort>", "Client port")).action(main);
+var getPreferredPmByRuntime = (runtime) => {
+  if (runtime === "bun") {
+    return "bun";
+  } else if (runtime === "deno") {
+    return "deno";
+  }
+};
 async function main(targetDir, options, command) {
   try {
-    consola.log(`${command.name()} version ${command.version()}`);
+    consola2.log(`${command.name()} version ${command.version()}`);
     const {
       install: installArg,
       runtime: runtimeArg,
@@ -39,7 +305,7 @@ async function main(targetDir, options, command) {
     let target = "";
     if (targetDir) {
       target = targetDir;
-      consola.success(`Using target directory \u2026 ${target}`);
+      consola2.success(`Using target directory \u2026 ${target}`);
     } else {
       const answer = await input({
         message: "Target directory",
@@ -49,9 +315,9 @@ async function main(targetDir, options, command) {
     }
     let projectName = "";
     if (target === ".") {
-      projectName = path.basename(process.cwd());
+      projectName = path2.basename(process.cwd());
     } else {
-      projectName = path.basename(target);
+      projectName = path2.basename(target);
     }
     const runtimeName = runtimeArg || await select({
       message: "Which runtime would you like to use?",
@@ -79,8 +345,8 @@ async function main(targetDir, options, command) {
     if (!templateName) {
       throw new Error("No template selected");
     }
-    if (fs.existsSync(target)) {
-      if (fs.readdirSync(target).length > 0) {
+    if (fs2.existsSync(target)) {
+      if (fs2.readdirSync(target).length > 0) {
         const response = await confirm({
           message: "Directory not empty. Continue?",
           default: false
@@ -99,10 +365,10 @@ async function main(targetDir, options, command) {
       template: templateName,
       target
     });
-    let packageManager = packageManagerArg;
-    if (runtimeName === "bun" && !packageManager) {
-      packageManager = "bun";
-    }
+    const packageManager = detectPackageManager({
+      preferredPm: getPreferredPmByRuntime(runtime.key),
+      cwd: target
+    });
     if (install) {
       await installDependencies({ target, packageManager });
     }
@@ -121,7 +387,7 @@ async function main(targetDir, options, command) {
         });
         clientPath = await input({
           message: "Path to generate the client to",
-          default: path.join(clientRoot, "gqty/index.ts"),
+          default: path2.join(clientRoot, "gqty/index.ts"),
           validate: (value) => {
             if (!value.startsWith(clientRoot === "." ? "" : clientRoot)) {
               return "Path must start with the client root";
@@ -134,23 +400,32 @@ async function main(targetDir, options, command) {
         message: "Port of the pylon server to generate the client from",
         default: "3000"
       });
-      consola.start(`Updating pylon dev script to generate client`);
-      const devScriptPath = path.join(target, "package.json");
-      const devScript = JSON.parse(fs.readFileSync(devScriptPath, "utf-8"));
-      devScript.scripts = {
-        ...devScript.scripts,
-        dev: devScript.scripts.dev + ` --client --client-port ${clientPort} --client-path ${clientPath}`
+      consola2.start(`Updating pylon dev script to generate client`);
+      let packagePath;
+      let scriptKey;
+      if (runtime.key === "deno") {
+        packagePath = path2.join(target, "deno.json");
+        scriptKey = "tasks";
+      } else {
+        packagePath = path2.join(target, "package.json");
+        scriptKey = "scripts";
+      }
+      const devScript = JSON.parse(fs2.readFileSync(packagePath, "utf-8"));
+      devScript[scriptKey] = {
+        ...devScript[scriptKey],
+        dev: devScript[scriptKey].dev + ` --client --client-port ${clientPort} --client-path ${clientPath}`
       };
-      fs.writeFileSync(devScriptPath, JSON.stringify(devScript, null, 2));
-      consola.success(`Pylon dev script updated`);
+      fs2.writeFileSync(packagePath, JSON.stringify(devScript, null, 2));
+      consola2.success(`Pylon dev script updated`);
     }
+    const runScript = getRunScript(packageManager);
     const message = `
 \uD83C\uDF89 ${chalk.green.bold("Pylon created successfully.")}
 
 \uD83D\uDCBB ${chalk.cyan.bold("Continue Developing")}
     ${chalk.yellow("Change directories:")} cd ${chalk.blue(target)}
-    ${chalk.yellow("Start dev server:")} npm run start
-    ${chalk.yellow("Deploy:")} npm run deploy
+    ${chalk.yellow("Start dev server:")} ${runScript} dev
+    ${chalk.yellow("Deploy:")} ${runScript} deploy
 
 \uD83D\uDCD6 ${chalk.cyan.bold("Explore Documentation")}
     ${chalk.underline.blue("https://pylon.cronit.io/docs")}
@@ -166,173 +441,12 @@ async function main(targetDir, options, command) {
       clientPath: clientPath || undefined,
       clientPort: parseInt(clientPort) || undefined
     });
-    consola.box(message);
+    consola2.box(message);
   } catch (e) {
-    consola.error(e);
+    consola2.error(e);
   }
 }
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = dirname(__filename2);
-var version = (() => {
-  return JSON.parse(fs.readFileSync(path.join(__dirname2, "..", "package.json"), "utf-8")).version;
-})();
-var runtimes = [
-  {
-    key: "bun",
-    name: "Bun.js",
-    website: "https://bunjs.dev",
-    templates: ["default"]
-  },
-  {
-    key: "node",
-    name: "Node.js",
-    website: "https://nodejs.org",
-    templates: ["default"]
-  },
-  {
-    key: "cf-workers",
-    name: "Cloudflare Workers",
-    website: "https://workers.cloudflare.com",
-    templates: ["default"]
-  }
-];
-var templates = [
-  {
-    key: "default",
-    name: "Default",
-    description: "Default template"
-  },
-  {
-    key: "database",
-    name: "Database (Prisma)",
-    description: "Template with Prisma ORM"
-  }
-];
-var injectVariablesInContent = (content, variables) => {
-  let result = content;
-  Object.entries(variables).forEach(([key, value]) => {
-    result = result.replaceAll(key, value);
-  });
-  return result;
-};
-var readdirFilesSyncRecursive = (dir) => {
-  const run = (dir2) => {
-    const result = [];
-    const files = fs.readdirSync(dir2);
-    files.forEach((file) => {
-      const filePath = path.join(dir2, file);
-      if (fs.statSync(filePath).isDirectory()) {
-        result.push(...run(filePath));
-      }
-      if (fs.statSync(filePath).isFile()) {
-        result.push(filePath);
-      }
-    });
-    return result;
-  };
-  return run(dir).map((file) => {
-    return file.replace(dir, ".");
-  });
-};
-var createTemplate = async (options) => {
-  const { runtime, template, target } = options;
-  const runtimeName = runtimes.find(({ key }) => key === runtime)?.name;
-  const templateName = templates.find(({ key }) => key === template)?.name;
-  if (!runtimeName) {
-    throw new Error(`Invalid runtime: ${runtime}`);
-  }
-  if (!templateName) {
-    throw new Error(`Invalid template: ${template}`);
-  }
-  const sharedTemplateDir = path.join(__dirname2, "..", "templates", "shared");
-  if (!fs.existsSync(sharedTemplateDir)) {
-    throw new Error(`Shared templates not found: ${sharedTemplateDir}`);
-  }
-  const templateDir = path.join(__dirname2, "..", "templates", runtime, template);
-  if (!fs.existsSync(templateDir)) {
-    throw new Error(`Template not found: ${templateDir}`);
-  }
-  const targetDirectoryPath = path.join(process.cwd(), target);
-  consola.start(`Creating pylon in ${targetDirectoryPath}`);
-  const inject = (content) => {
-    return injectVariablesInContent(content, {
-      __PYLON_NAME__: options.name
-    });
-  };
-  readdirFilesSyncRecursive(sharedTemplateDir).forEach((file) => {
-    const source = path.join(sharedTemplateDir, file);
-    let target2 = path.join(targetDirectoryPath, file);
-    const targetDir = path.dirname(target2);
-    if (runtime === "cf-workers" && source.includes(".github/workflows/publish.yaml")) {
-      return;
-    }
-    if (!fs.existsSync(targetDir)) {
-      fs.mkdirSync(targetDir, { recursive: true });
-    }
-    if (target2.endsWith(".example")) {
-      target2 = target2.replace(".example", "");
-    }
-    const injectedContent = inject(fs.readFileSync(source, "utf-8"));
-    fs.writeFileSync(target2, injectedContent);
-  });
-  readdirFilesSyncRecursive(templateDir).forEach((file) => {
-    const source = path.join(templateDir, file);
-    let target2 = path.join(targetDirectoryPath, file);
-    const targetDir = path.dirname(target2);
-    if (!fs.existsSync(targetDir)) {
-      fs.mkdirSync(targetDir, { recursive: true });
-    }
-    if (target2.endsWith(".example")) {
-      target2 = target2.replace(".example", "");
-    }
-    const injectedContent = inject(fs.readFileSync(source, "utf-8"));
-    fs.writeFileSync(target2, injectedContent);
-  });
-  consola.success(`Pylon created`);
-};
-var installDependencies = async (args) => {
-  const target = path.resolve(args.target);
-  console.log("target", target);
-  if (!args.packageManager) {
-    args.packageManager = await detect({
-      cwd: target,
-      includeGlobalBun: true
-    });
-  }
-  if (!args.packageManager) {
-    throw new Error("No package manager found");
-  }
-  const { packageManager } = args;
-  let command = "";
-  switch (packageManager) {
-    case "yarn":
-      command = "yarn";
-      break;
-    case "npm":
-      command = "npm install";
-      break;
-    case "pnpm":
-      command = "pnpm install";
-      break;
-    case "bun":
-      command = "bun install";
-      break;
-    default:
-      throw new Error(`Invalid package manager: ${packageManager}`);
-  }
-  consola.start(`Installing dependencies using ${packageManager}`);
-  const proc = spawnSync(command, {
-    cwd: target,
-    shell: true,
-    stdio: "inherit"
-  });
-  if (proc.status !== 0) {
-    throw new Error(`Failed to install dependencies`);
-  }
-  consola.success(`Dependencies installed`);
-};
-program.name("create-pylon").version(version).arguments("[target]").addOption(new Option("-i, --install", "Install dependencies")).addOption(new Option("-r, --runtime <runtime>", "Runtime").choices(runtimes.map(({ key }) => key))).addOption(new Option("-t, --template <template>", "Template")).addOption(new Option("-pm, --package-manager <packageManager>", "Package manager")).addOption(new Option("--client", "Enable client generation (https://pylon.cronit.io/docs/integrations/gqty)")).addOption(new Option("--client-path <clientPath>", "Client path")).addOption(new Option("--client-port <clientPort>", "Client port")).action(main);
 program.parse();
 
-//# debugId=55AF547960838BB164756E2164756E21
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts"],
  "sourcesContent": [
    "#!/usr/bin/env node\n\nimport {Option, program, type Command} from 'commander'\nimport consola from 'consola'\nimport {input, select, confirm} from '@inquirer/prompts'\nimport path from 'path'\nimport chalk from 'chalk'\nimport * as fs from 'fs'\n\nimport * as telemetry from '@getcronit/pylon-telemetry'\n\nimport {fileURLToPath} from 'url'\nimport {dirname} from 'path'\n\nconst __filename = fileURLToPath(import.meta.url)\nconst __dirname = dirname(__filename)\n\nconst version = (() => {\n  return JSON.parse(\n    fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8')\n  ).version as string\n})()\n\nfunction mkdirp(dir: string) {\n  try {\n    fs.mkdirSync(dir, {recursive: true})\n  } catch (e) {\n    if (e instanceof Error) {\n      if ('code' in e && e.code === 'EEXIST') return\n    }\n    throw e\n  }\n}\n\nconst runtimes: {\n  key: string\n  name: string\n  website: string\n  templates?: string[]\n}[] = [\n  {\n    key: 'bun',\n    name: 'Bun.js',\n    website: 'https://bunjs.dev',\n    templates: ['default']\n  },\n  {\n    key: 'node',\n    name: 'Node.js',\n    website: 'https://nodejs.org',\n    templates: ['default']\n  },\n  {\n    key: 'cf-workers',\n    name: 'Cloudflare Workers',\n    website: 'https://workers.cloudflare.com',\n    templates: ['default']\n  }\n]\n\nconst templates: {\n  key: string\n  name: string\n  description: string\n}[] = [\n  {\n    key: 'default',\n    name: 'Default',\n    description: 'Default template'\n  },\n  {\n    key: 'database',\n    name: 'Database (Prisma)',\n    description: 'Template with Prisma ORM'\n  }\n]\n\nconst injectVariablesInContent = (\n  content: string,\n  variables: Record<string, string>\n) => {\n  let result = content\n\n  Object.entries(variables).forEach(([key, value]) => {\n    result = result.replaceAll(key, value)\n  })\n\n  return result\n}\nconst readdirFilesSyncRecursive = (dir: string): string[] => {\n  const run = (dir: string): string[] => {\n    const result: string[] = []\n\n    const files = fs.readdirSync(dir)\n\n    files.forEach(file => {\n      const filePath = path.join(dir, file)\n\n      if (fs.statSync(filePath).isDirectory()) {\n        result.push(...run(filePath))\n      }\n\n      // Only add files\n      if (fs.statSync(filePath).isFile()) {\n        result.push(filePath)\n      }\n    })\n\n    return result\n  }\n\n  return run(dir).map(file => {\n    return file.replace(dir, '.')\n  })\n}\n\nconst createTemplate = async (options: {\n  name: string\n  runtime: string\n  template: string\n  target: string\n}) => {\n  const {runtime, template, target} = options\n\n  const runtimeName = runtimes.find(({key}) => key === runtime)?.name\n  const templateName = templates.find(({key}) => key === template)?.name\n\n  if (!runtimeName) {\n    throw new Error(`Invalid runtime: ${runtime}`)\n  }\n\n  if (!templateName) {\n    throw new Error(`Invalid template: ${template}`)\n  }\n\n  // The templates are stored in the `templates` directory\n  const sharedTemplateDir = path.join(__dirname, '..', 'templates', 'shared')\n\n  if (!fs.existsSync(sharedTemplateDir)) {\n    throw new Error(`Shared templates not found: ${sharedTemplateDir}`)\n  }\n\n  const templateDir = path.join(__dirname, '..', 'templates', runtime, template)\n\n  if (!fs.existsSync(templateDir)) {\n    throw new Error(`Template not found: ${templateDir}`)\n  }\n\n  // The target directory is already created\n  const targetDirectoryPath = path.join(process.cwd(), target)\n\n  consola.start(`Creating pylon in ${targetDirectoryPath}`)\n\n  const inject = (content: string) => {\n    return injectVariablesInContent(content, {\n      __PYLON_NAME__: options.name\n    })\n  }\n\n  // Copy the shared template files\n  readdirFilesSyncRecursive(sharedTemplateDir).forEach(file => {\n    const source = path.join(sharedTemplateDir, file)\n    let target = path.join(targetDirectoryPath, file)\n\n    // Create folder recursively and copy file\n\n    const targetDir = path.dirname(target)\n\n    // Skip the .github/workflows directory for cf-workers runtime\n    if (\n      runtime === 'cf-workers' &&\n      source.includes('.github/workflows/publish.yaml')\n    ) {\n      return\n    }\n\n    if (!fs.existsSync(targetDir)) {\n      fs.mkdirSync(targetDir, {recursive: true})\n    }\n\n    // If the target ends with `.example`, remove the suffix.\n    // This is useful for `.gitignore.example` files because they are not published in\n    // the `create-pylon` package when named `.gitignore`.\n    if (target.endsWith('.example')) {\n      target = target.replace('.example', '')\n    }\n\n    const injectedContent = inject(fs.readFileSync(source, 'utf-8'))\n\n    fs.writeFileSync(target, injectedContent)\n  })\n\n  // Copy the runtime specific template files\n  readdirFilesSyncRecursive(templateDir).forEach(file => {\n    const source = path.join(templateDir, file)\n    let target = path.join(targetDirectoryPath, file)\n\n    // Create folder recursively and copy file\n    const targetDir = path.dirname(target)\n\n    if (!fs.existsSync(targetDir)) {\n      fs.mkdirSync(targetDir, {recursive: true})\n    }\n\n    // If the target ends with `.example`, remove the suffix.\n    // This is useful for `.gitignore.example` files because they are not published in\n    // the `create-pylon` package when named `.gitignore`.\n    if (target.endsWith('.example')) {\n      target = target.replace('.example', '')\n    }\n\n    const injectedContent = inject(fs.readFileSync(source, 'utf-8'))\n\n    fs.writeFileSync(target, injectedContent)\n  })\n\n  consola.success(`Pylon created`)\n}\n\nimport {detect} from 'detect-package-manager'\nimport {spawnSync} from 'child_process'\n\nconst installDependencies = async (args: {\n  target: string\n  packageManager?: string\n}) => {\n  const target = path.resolve(args.target)\n\n  console.log('target', target)\n\n  if (!args.packageManager) {\n    args.packageManager = await detect({\n      cwd: target,\n      includeGlobalBun: true\n    })\n  }\n\n  if (!args.packageManager) {\n    throw new Error('No package manager found')\n  }\n\n  // yarn', 'npm', or 'pnpm', 'bun'\n  const {packageManager} = args\n\n  let command = ''\n\n  switch (packageManager) {\n    case 'yarn':\n      command = 'yarn'\n      break\n    case 'npm':\n      command = 'npm install'\n      break\n    case 'pnpm':\n      command = 'pnpm install'\n      break\n    case 'bun':\n      command = 'bun install'\n      break\n    default:\n      throw new Error(`Invalid package manager: ${packageManager}`)\n  }\n\n  consola.start(`Installing dependencies using ${packageManager}`)\n\n  const proc = spawnSync(command, {\n    cwd: target,\n    shell: true,\n    stdio: 'inherit'\n  })\n\n  if (proc.status !== 0) {\n    throw new Error(`Failed to install dependencies`)\n  }\n\n  consola.success(`Dependencies installed`)\n}\n\nprogram\n  .name('create-pylon')\n  .version(version)\n  .arguments('[target]')\n  .addOption(new Option('-i, --install', 'Install dependencies'))\n  .addOption(\n    new Option('-r, --runtime <runtime>', 'Runtime').choices(\n      runtimes.map(({key}) => key)\n    )\n  )\n  .addOption(new Option('-t, --template <template>', 'Template'))\n  .addOption(\n    new Option('-pm, --package-manager <packageManager>', 'Package manager')\n  )\n  .addOption(\n    new Option(\n      '--client',\n      'Enable client generation (https://pylon.cronit.io/docs/integrations/gqty)'\n    )\n  )\n  .addOption(new Option('--client-path <clientPath>', 'Client path'))\n  .addOption(new Option('--client-port <clientPort>', 'Client port'))\n  .action(main)\n\ntype ArgOptions = {\n  install: boolean\n  runtime: string\n  template: string\n  packageManager?: string\n  client?: boolean\n  clientPath?: string\n  clientPort?: string\n}\n\nasync function main(\n  targetDir: string | undefined,\n  options: ArgOptions,\n  command: Command\n) {\n  try {\n    consola.log(`${command.name()} version ${command.version()}`)\n\n    const {\n      install: installArg,\n      runtime: runtimeArg,\n      template: templateArg,\n      packageManager: packageManagerArg,\n      client: clientArg,\n      clientPath: clientPathArg,\n      clientPort: clientPortArg\n    } = options\n\n    let target = ''\n\n    if (targetDir) {\n      target = targetDir\n\n      consola.success(`Using target directory … ${target}`)\n    } else {\n      const answer = await input({\n        message: 'Target directory',\n        default: 'my-pylon'\n      })\n      target = answer\n    }\n\n    let projectName = ''\n\n    if (target === '.') {\n      projectName = path.basename(process.cwd())\n    } else {\n      projectName = path.basename(target)\n    }\n\n    const runtimeName =\n      runtimeArg ||\n      (await select({\n        message: 'Which runtime would you like to use?',\n        choices: runtimes.map(runtime => ({\n          name: `${runtime.name} (${runtime.website})`,\n          value: runtime.key\n        })),\n        default: 0\n      }))\n\n    if (!runtimeName) {\n      throw new Error('No runtime selected')\n    }\n\n    const runtime = runtimes.find(({key}) => key === runtimeName)\n\n    if (!runtime) {\n      throw new Error(`Invalid runtime selected: ${runtimeName}`)\n    }\n\n    const templateName =\n      templateArg ||\n      (await select({\n        message: 'Which template would you like to use?',\n        choices: templates\n          .filter(template => runtime.templates?.includes(template.key))\n          .map(template => ({\n            name: template.name,\n            value: template.key\n          })),\n        default: 0\n      }))\n\n    if (!templateName) {\n      throw new Error('No template selected')\n    }\n\n    if (fs.existsSync(target)) {\n      if (fs.readdirSync(target).length > 0) {\n        const response = await confirm({\n          message: 'Directory not empty. Continue?',\n          default: false\n        })\n        if (!response) {\n          process.exit(1)\n        }\n      }\n    } else {\n      mkdirp(target)\n    }\n\n    const install =\n      installArg ||\n      (await confirm({message: 'Would you like to install dependencies?'}))\n\n    await createTemplate({\n      name: projectName,\n      runtime: runtimeName,\n      template: templateName,\n      target\n    })\n\n    let packageManager = packageManagerArg\n\n    if (runtimeName === 'bun' && !packageManager) {\n      packageManager = 'bun'\n    }\n\n    if (install) {\n      await installDependencies({target, packageManager})\n    }\n\n    const client =\n      clientArg ||\n      (await confirm({\n        message:\n          'Would you like to enable client generation? (https://pylon.cronit.io/docs/integrations/gqty)',\n        default: false\n      }))\n\n    let clientRoot: string = ''\n    let clientPath: string = ''\n    let clientPort: string = ''\n\n    if (client) {\n      if (!clientPathArg) {\n        clientRoot = await input({\n          message: 'Path to the root where the client should be generated',\n          default: '.'\n        })\n\n        clientPath = await input({\n          message: 'Path to generate the client to',\n          default: path.join(clientRoot, 'gqty/index.ts'),\n          validate: value => {\n            // Check if the path starts with the client root (take care of .)\n            if (!value.startsWith(clientRoot === '.' ? '' : clientRoot)) {\n              return 'Path must start with the client root'\n            }\n\n            return true\n          }\n        })\n      }\n\n      clientPort =\n        clientPortArg ||\n        (await input({\n          message: 'Port of the pylon server to generate the client from',\n          default: '3000'\n        }))\n\n      consola.start(`Updating pylon dev script to generate client`)\n\n      const devScriptPath = path.join(target, 'package.json')\n\n      const devScript = JSON.parse(fs.readFileSync(devScriptPath, 'utf-8'))\n\n      devScript.scripts = {\n        ...devScript.scripts,\n        dev:\n          devScript.scripts.dev +\n          ` --client --client-port ${clientPort} --client-path ${clientPath}`\n      }\n\n      fs.writeFileSync(devScriptPath, JSON.stringify(devScript, null, 2))\n\n      consola.success(`Pylon dev script updated`)\n    }\n\n    const message = `\n🎉 ${chalk.green.bold('Pylon created successfully.')}\n\n💻 ${chalk.cyan.bold('Continue Developing')}\n    ${chalk.yellow('Change directories:')} cd ${chalk.blue(target)}\n    ${chalk.yellow('Start dev server:')} npm run start\n    ${chalk.yellow('Deploy:')} npm run deploy\n\n📖 ${chalk.cyan.bold('Explore Documentation')}\n    ${chalk.underline.blue('https://pylon.cronit.io/docs')}\n\n💬 ${chalk.cyan.bold('Join our Community')}\n    ${chalk.underline.blue('https://discord.gg/cbJjkVrnHe')}\n`\n\n    await telemetry.sendCreateEvent({\n      name: projectName,\n      pylonCreateVersion: version,\n      runtime: runtimeName,\n      template: templateName,\n      clientPath: clientPath || undefined,\n      clientPort: parseInt(clientPort) || undefined\n    })\n\n    consola.box(message)\n  } catch (e) {\n    consola.error(e)\n  }\n}\n\nprogram.parse()\n"
  ],
  "mappings": "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",
  "debugId": "55AF547960838BB164756E2164756E21",
  "names": []
}
+//# debugId=49FD4AB53F50782964756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/detect-pm.ts"],
  "sourcesContent": [
    "#!/usr/bin/env node\n\nimport {Option, program, type Command} from 'commander'\nimport consola from 'consola'\nimport {input, select, confirm} from '@inquirer/prompts'\nimport path from 'path'\nimport chalk from 'chalk'\nimport * as fs from 'fs'\n\nimport * as telemetry from '@getcronit/pylon-telemetry'\n\nimport {fileURLToPath} from 'url'\nimport {dirname} from 'path'\n\nconst __filename = fileURLToPath(import.meta.url)\nconst __dirname = dirname(__filename)\n\nconst version = (() => {\n  return JSON.parse(\n    fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8')\n  ).version as string\n})()\n\nfunction mkdirp(dir: string) {\n  try {\n    fs.mkdirSync(dir, {recursive: true})\n  } catch (e) {\n    if (e instanceof Error) {\n      if ('code' in e && e.code === 'EEXIST') return\n    }\n    throw e\n  }\n}\n\nconst runtimes: {\n  key: string\n  name: string\n  website: string\n  templates?: string[]\n}[] = [\n  {\n    key: 'bun',\n    name: 'Bun.js',\n    website: 'https://bunjs.dev',\n    templates: ['default']\n  },\n  {\n    key: 'node',\n    name: 'Node.js',\n    website: 'https://nodejs.org',\n    templates: ['default']\n  },\n  {\n    key: 'cf-workers',\n    name: 'Cloudflare Workers',\n    website: 'https://workers.cloudflare.com',\n    templates: ['default']\n  },\n  {\n    key: 'deno',\n    name: 'Deno',\n    website: 'https://deno.land',\n    templates: ['default']\n  }\n]\n\nconst templates: {\n  key: string\n  name: string\n  description: string\n}[] = [\n  {\n    key: 'default',\n    name: 'Default',\n    description: 'Default template'\n  },\n  {\n    key: 'database',\n    name: 'Database (Prisma)',\n    description: 'Template with Prisma ORM'\n  }\n]\n\nconst injectVariablesInContent = (\n  content: string,\n  variables: Record<string, string>\n) => {\n  let result = content\n\n  Object.entries(variables).forEach(([key, value]) => {\n    result = result.replaceAll(key, value)\n  })\n\n  return result\n}\nconst readdirFilesSyncRecursive = (dir: string): string[] => {\n  const run = (dir: string): string[] => {\n    const result: string[] = []\n\n    const files = fs.readdirSync(dir)\n\n    files.forEach(file => {\n      const filePath = path.join(dir, file)\n\n      if (fs.statSync(filePath).isDirectory()) {\n        result.push(...run(filePath))\n      }\n\n      // Only add files\n      if (fs.statSync(filePath).isFile()) {\n        result.push(filePath)\n      }\n    })\n\n    return result\n  }\n\n  return run(dir).map(file => {\n    return file.replace(dir, '.')\n  })\n}\n\nconst createTemplate = async (options: {\n  name: string\n  runtime: string\n  template: string\n  target: string\n}) => {\n  const {runtime, template, target} = options\n\n  const runtimeName = runtimes.find(({key}) => key === runtime)?.name\n  const templateName = templates.find(({key}) => key === template)?.name\n\n  if (!runtimeName) {\n    throw new Error(`Invalid runtime: ${runtime}`)\n  }\n\n  if (!templateName) {\n    throw new Error(`Invalid template: ${template}`)\n  }\n\n  // The templates are stored in the `templates` directory\n  const sharedTemplateDir = path.join(__dirname, '..', 'templates', 'shared')\n\n  if (!fs.existsSync(sharedTemplateDir)) {\n    throw new Error(`Shared templates not found: ${sharedTemplateDir}`)\n  }\n\n  const templateDir = path.join(__dirname, '..', 'templates', runtime, template)\n\n  if (!fs.existsSync(templateDir)) {\n    throw new Error(`Template not found: ${templateDir}`)\n  }\n\n  // The target directory is already created\n  const targetDirectoryPath = path.join(process.cwd(), target)\n\n  consola.start(`Creating pylon in ${targetDirectoryPath}`)\n\n  const inject = (content: string) => {\n    return injectVariablesInContent(content, {\n      __PYLON_NAME__: options.name\n    })\n  }\n\n  // Copy the shared template files\n  readdirFilesSyncRecursive(sharedTemplateDir).forEach(file => {\n    const source = path.join(sharedTemplateDir, file)\n    let target = path.join(targetDirectoryPath, file)\n\n    // Create folder recursively and copy file\n\n    const targetDir = path.dirname(target)\n\n    // Skip the .github/workflows directory for cf-workers runtime\n    if (\n      runtime === 'cf-workers' &&\n      source.includes('.github/workflows/publish.yaml')\n    ) {\n      return\n    }\n\n    if (!fs.existsSync(targetDir)) {\n      fs.mkdirSync(targetDir, {recursive: true})\n    }\n\n    // If the target ends with `.example`, remove the suffix.\n    // This is useful for `.gitignore.example` files because they are not published in\n    // the `create-pylon` package when named `.gitignore`.\n    if (target.endsWith('.example')) {\n      target = target.replace('.example', '')\n    }\n\n    const injectedContent = inject(fs.readFileSync(source, 'utf-8'))\n\n    fs.writeFileSync(target, injectedContent)\n  })\n\n  // Copy the runtime specific template files\n  readdirFilesSyncRecursive(templateDir).forEach(file => {\n    const source = path.join(templateDir, file)\n    let target = path.join(targetDirectoryPath, file)\n\n    // Create folder recursively and copy file\n    const targetDir = path.dirname(target)\n\n    if (!fs.existsSync(targetDir)) {\n      fs.mkdirSync(targetDir, {recursive: true})\n    }\n\n    // If the target ends with `.example`, remove the suffix.\n    // This is useful for `.gitignore.example` files because they are not published in\n    // the `create-pylon` package when named `.gitignore`.\n    if (target.endsWith('.example')) {\n      target = target.replace('.example', '')\n    }\n\n    const injectedContent = inject(fs.readFileSync(source, 'utf-8'))\n\n    fs.writeFileSync(target, injectedContent)\n  })\n\n  consola.success(`Pylon created`)\n}\n\nimport {spawnSync} from 'child_process'\nimport {detectPackageManager, getRunScript, PackageManager} from './detect-pm'\n\nconst installDependencies = async (args: {\n  target: string\n  packageManager: PackageManager\n}) => {\n  const target = path.resolve(args.target)\n  const packageManager = args.packageManager\n\n  let command = ''\n\n  switch (packageManager) {\n    case 'yarn':\n      command = 'yarn'\n      break\n    case 'npm':\n      command = 'npm install'\n      break\n    case 'pnpm':\n      command = 'pnpm install'\n      break\n    case 'bun':\n      command = 'bun install'\n      break\n    case 'deno':\n      command = 'deno install'\n      break\n    default:\n      throw new Error(`Invalid package manager: ${packageManager}`)\n  }\n\n  consola.start(`Installing dependencies using ${packageManager}`)\n\n  const proc = spawnSync(command, {\n    cwd: target,\n    shell: true,\n    stdio: 'inherit'\n  })\n\n  if (proc.status !== 0) {\n    throw new Error(`Failed to install dependencies`)\n  }\n\n  consola.success(`Dependencies installed`)\n}\n\nprogram\n  .name('create-pylon')\n  .version(version)\n  .arguments('[target]')\n  .addOption(new Option('-i, --install', 'Install dependencies'))\n  .addOption(\n    new Option('-r, --runtime <runtime>', 'Runtime').choices(\n      runtimes.map(({key}) => key)\n    )\n  )\n  .addOption(new Option('-t, --template <template>', 'Template'))\n  .addOption(\n    new Option('-pm, --package-manager <packageManager>', 'Package manager')\n  )\n  .addOption(\n    new Option(\n      '--client',\n      'Enable client generation (https://pylon.cronit.io/docs/integrations/gqty)'\n    )\n  )\n  .addOption(new Option('--client-path <clientPath>', 'Client path'))\n  .addOption(new Option('--client-port <clientPort>', 'Client port'))\n  .action(main)\n\ntype ArgOptions = {\n  install: boolean\n  runtime: string\n  template: string\n  packageManager?: PackageManager\n  client?: boolean\n  clientPath?: string\n  clientPort?: string\n}\n\nconst getPreferredPmByRuntime = (\n  runtime: string\n): PackageManager | undefined => {\n  if (runtime === 'bun') {\n    return 'bun'\n  } else if (runtime === 'deno') {\n    return 'deno'\n  }\n}\n\nasync function main(\n  targetDir: string | undefined,\n  options: ArgOptions,\n  command: Command\n) {\n  try {\n    consola.log(`${command.name()} version ${command.version()}`)\n\n    const {\n      install: installArg,\n      runtime: runtimeArg,\n      template: templateArg,\n      packageManager: packageManagerArg,\n      client: clientArg,\n      clientPath: clientPathArg,\n      clientPort: clientPortArg\n    } = options\n\n    let target = ''\n\n    if (targetDir) {\n      target = targetDir\n\n      consola.success(`Using target directory … ${target}`)\n    } else {\n      const answer = await input({\n        message: 'Target directory',\n        default: 'my-pylon'\n      })\n      target = answer\n    }\n\n    let projectName = ''\n\n    if (target === '.') {\n      projectName = path.basename(process.cwd())\n    } else {\n      projectName = path.basename(target)\n    }\n\n    const runtimeName =\n      runtimeArg ||\n      (await select({\n        message: 'Which runtime would you like to use?',\n        choices: runtimes.map(runtime => ({\n          name: `${runtime.name} (${runtime.website})`,\n          value: runtime.key\n        })),\n        default: 0\n      }))\n\n    if (!runtimeName) {\n      throw new Error('No runtime selected')\n    }\n\n    const runtime = runtimes.find(({key}) => key === runtimeName)\n\n    if (!runtime) {\n      throw new Error(`Invalid runtime selected: ${runtimeName}`)\n    }\n\n    const templateName =\n      templateArg ||\n      (await select({\n        message: 'Which template would you like to use?',\n        choices: templates\n          .filter(template => runtime.templates?.includes(template.key))\n          .map(template => ({\n            name: template.name,\n            value: template.key\n          })),\n        default: 0\n      }))\n\n    if (!templateName) {\n      throw new Error('No template selected')\n    }\n\n    if (fs.existsSync(target)) {\n      if (fs.readdirSync(target).length > 0) {\n        const response = await confirm({\n          message: 'Directory not empty. Continue?',\n          default: false\n        })\n        if (!response) {\n          process.exit(1)\n        }\n      }\n    } else {\n      mkdirp(target)\n    }\n\n    const install =\n      installArg ||\n      (await confirm({message: 'Would you like to install dependencies?'}))\n\n    await createTemplate({\n      name: projectName,\n      runtime: runtimeName,\n      template: templateName,\n      target\n    })\n\n    const packageManager = detectPackageManager({\n      preferredPm: getPreferredPmByRuntime(runtime.key),\n      cwd: target\n    })\n\n    if (install) {\n      await installDependencies({target, packageManager})\n    }\n\n    const client =\n      clientArg ||\n      (await confirm({\n        message:\n          'Would you like to enable client generation? (https://pylon.cronit.io/docs/integrations/gqty)',\n        default: false\n      }))\n\n    let clientRoot: string = ''\n    let clientPath: string = ''\n    let clientPort: string = ''\n\n    if (client) {\n      if (!clientPathArg) {\n        clientRoot = await input({\n          message: 'Path to the root where the client should be generated',\n          default: '.'\n        })\n\n        clientPath = await input({\n          message: 'Path to generate the client to',\n          default: path.join(clientRoot, 'gqty/index.ts'),\n          validate: value => {\n            // Check if the path starts with the client root (take care of .)\n            if (!value.startsWith(clientRoot === '.' ? '' : clientRoot)) {\n              return 'Path must start with the client root'\n            }\n\n            return true\n          }\n        })\n      }\n\n      clientPort =\n        clientPortArg ||\n        (await input({\n          message: 'Port of the pylon server to generate the client from',\n          default: '3000'\n        }))\n\n      consola.start(`Updating pylon dev script to generate client`)\n\n      let packagePath: string\n      let scriptKey: string\n      if (runtime.key === 'deno') {\n        packagePath = path.join(target, 'deno.json')\n        scriptKey = 'tasks'\n      } else {\n        packagePath = path.join(target, 'package.json')\n        scriptKey = 'scripts'\n      }\n\n      const devScript = JSON.parse(fs.readFileSync(packagePath, 'utf-8'))\n\n      devScript[scriptKey] = {\n        ...devScript[scriptKey],\n        dev:\n          devScript[scriptKey].dev +\n          ` --client --client-port ${clientPort} --client-path ${clientPath}`\n      }\n\n      fs.writeFileSync(packagePath, JSON.stringify(devScript, null, 2))\n\n      consola.success(`Pylon dev script updated`)\n    }\n\n    const runScript = getRunScript(packageManager)\n\n    const message = `\n🎉 ${chalk.green.bold('Pylon created successfully.')}\n\n💻 ${chalk.cyan.bold('Continue Developing')}\n    ${chalk.yellow('Change directories:')} cd ${chalk.blue(target)}\n    ${chalk.yellow('Start dev server:')} ${runScript} dev\n    ${chalk.yellow('Deploy:')} ${runScript} deploy\n\n📖 ${chalk.cyan.bold('Explore Documentation')}\n    ${chalk.underline.blue('https://pylon.cronit.io/docs')}\n\n💬 ${chalk.cyan.bold('Join our Community')}\n    ${chalk.underline.blue('https://discord.gg/cbJjkVrnHe')}\n`\n\n    await telemetry.sendCreateEvent({\n      name: projectName,\n      pylonCreateVersion: version,\n      runtime: runtimeName,\n      template: templateName,\n      clientPath: clientPath || undefined,\n      clientPort: parseInt(clientPort) || undefined\n    })\n\n    consola.box(message)\n  } catch (e) {\n    consola.error(e)\n  }\n}\n\nprogram.parse()\n",
    "import * as fs from 'node:fs'\nimport * as path from 'node:path'\nimport process from 'node:process'\nimport {execSync} from 'node:child_process'\nimport consola from 'consola'\n\n// Helper function to check if a command exists\nfunction isCommandAvailable(command: string): boolean {\n  try {\n    execSync(`${command} --version`, {stdio: 'ignore'})\n    return true\n  } catch (e) {\n    console.error(e)\n    return false\n  }\n}\n\n// Detect Bun\nfunction isBun(): boolean {\n  // @ts-ignore: Bun may not be defined\n  return typeof Bun !== 'undefined' && isCommandAvailable('bun')\n}\n\n// Detect npm\nfunction isNpm(): boolean {\n  return process.env.npm_execpath?.includes('npm') ?? false\n}\n\n// Detect Yarn\nfunction isYarn(): boolean {\n  return process.env.npm_execpath?.includes('yarn') ?? false\n}\n\n// Detect Deno\nfunction isDeno(): boolean {\n  // @ts-ignore: Deno may not be defined\n  return typeof Deno !== 'undefined' && isCommandAvailable('deno')\n}\n\n// Detect pnpm\nfunction isPnpm(): boolean {\n  return process.env.npm_execpath?.includes('pnpm') ?? false\n}\n\n// Detect based on lock files\nfunction detectByLockFiles(cwd: string): PackageManager | null {\n  if (fs.existsSync(path.join(cwd, 'bun.lockb'))) {\n    return 'bun'\n  }\n  if (fs.existsSync(path.join(cwd, 'package-lock.json'))) {\n    return 'npm'\n  }\n  if (fs.existsSync(path.join(cwd, 'yarn.lock'))) {\n    return 'yarn'\n  }\n  if (\n    fs.existsSync(path.join(cwd, 'deno.json')) ||\n    fs.existsSync(path.join(cwd, 'deno.lock'))\n  ) {\n    return 'deno'\n  }\n  if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'))) {\n    return 'pnpm'\n  }\n  return null\n}\n\nexport type PackageManager =\n  | 'bun'\n  | 'npm'\n  | 'yarn'\n  | 'pnpm'\n  | 'deno'\n  | 'unknown'\n\n// Main detection function\nexport function detectPackageManager({\n  preferredPm,\n  cwd = process.cwd()\n}: {\n  preferredPm?: PackageManager\n  cwd?: string\n}): PackageManager {\n  // Check the preferred package manager first\n  if (preferredPm && isCommandAvailable(preferredPm)) {\n    return preferredPm\n  }\n\n  // Proceed with detection logic\n  if (isBun()) {\n    return 'bun'\n  }\n  if (isNpm()) {\n    return 'npm'\n  }\n  if (isPnpm()) {\n    return 'pnpm'\n  }\n  if (isDeno()) {\n    return 'deno'\n  }\n  if (isYarn()) {\n    return 'yarn'\n  }\n\n  // Fallback to lock file detection\n  const lockFileDetection = detectByLockFiles(cwd)\n  if (lockFileDetection) {\n    consola.info(`Detected package manager by lock file: ${lockFileDetection}`)\n    if (isCommandAvailable(lockFileDetection)) {\n      return lockFileDetection\n    } else {\n      consola.warn(\n        `Lock file detected, but ${lockFileDetection} is not installed.`\n      )\n    }\n  }\n\n  return 'unknown'\n}\n\ntype PackageManagerScript =\n  | 'bun'\n  | 'npm run'\n  | 'yarn'\n  | 'pnpm run'\n  | 'deno task'\n\n// Run script detection\nexport function getRunScript(pm: PackageManager): PackageManagerScript {\n  switch (pm) {\n    case 'bun':\n      return 'bun'\n    case 'npm':\n      return 'npm run'\n    case 'yarn':\n      return 'yarn'\n    case 'pnpm':\n      return 'pnpm run'\n    case 'deno':\n      return 'deno task'\n    default:\n      throw new Error('Unknown package manager')\n  }\n}\n"
  ],
  "mappings": "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",
  "debugId": "49FD4AB53F50782964756E2164756E21",
  "names": []
}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-pylon",
   "type": "module",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "CLI for creating a Pylon",
   "scripts": {
     "build": "bun build ./src/index.ts --target=bun --outdir=./dist --sourcemap=inline --packages external"
@@ -24,7 +24,6 @@
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "consola": "^3.2.3",
-    "detect-package-manager": "^3.0.2",
     "@getcronit/pylon-telemetry": "^1.0.0"
   },
   "engines": {

package/templates/bun/default/package.json

@@ -5,7 +5,7 @@
   "type": "module",
   "description": "Generated with `npm create pylon`",
   "scripts": {
-    "dev": "pylon dev -c 'bun run .pylon/index.js'",
+    "dev": "pylon dev -c \"bun run .pylon/index.js\"",
     "build": "pylon build"
   },
   "dependencies": {

package/templates/cf-workers/default/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "scripts": {
     "deploy": "pylon build && wrangler deploy",
-    "dev": "pylon dev -c 'wrangler dev'",
+    "dev": "pylon dev -c \"wrangler dev\"",
     "cf-typegen": "wrangler types"
   },
   "dependencies": {

package/templates/deno/default/.vscode/extensions.json

@@ -0,0 +1,5 @@
+{
+  "recommendations": [
+    "denoland.vscode-deno"
+  ]
+}

package/templates/deno/default/.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+  "deno.enablePaths": [
+    "./"
+  ],
+  "editor.inlayHints.enabled": "off"
+}

package/templates/deno/default/Dockerfile

@@ -0,0 +1,12 @@
+FROM denoland/deno
+
+EXPOSE 3000
+
+WORKDIR /app
+
+ADD . /app
+
+RUN deno install
+RUN deno task build
+
+CMD ["run", "-A", ".pylon/index.js"]

package/templates/deno/default/deno.json

@@ -0,0 +1,15 @@
+{
+  "imports": {
+    "@getcronit/pylon-dev": "npm:@getcronit/pylon-dev@^1.0.1",
+    "@getcronit/pylon": "npm:@getcronit/pylon@^2.2.1"
+  },
+  "tasks": {
+    "dev": "pylon dev -c 'deno run -A .pylon/index.js --config tsconfig.json'",
+    "build": "pylon build"
+  },
+  "compilerOptions": {
+    "jsx": "precompile",
+    "jsxImportSource": "hono/jsx"
+  },
+  "nodeModulesDir": "auto"
+}

package/templates/deno/default/src/index.ts

@@ -0,0 +1,17 @@
+import {app} from '@getcronit/pylon'
+
+export const graphql = {
+  Query: {
+    hello: () => {
+      return 'Hello, world!'
+    }
+  },
+  Mutation: {}
+}
+
+Deno.serve(
+  {
+    port: 3000
+  },
+  app.fetch
+)

package/templates/node/default/package.json

@@ -5,7 +5,7 @@
   "type": "module",
   "description": "Generated with `npm create pylon`",
   "scripts": {
-    "dev": "pylon dev -c 'node --enable-source-maps .pylon/index.js'",
+    "dev": "pylon dev -c \"node --enable-source-maps .pylon/index.js\"",
     "build": "pylon build"
   },
   "dependencies": {