create-bunli 0.8.0 → 0.8.2

package/dist/index.js

@@ -1,289 +1,4 @@
 // @bun
-// src/template-engine.ts
-import { downloadTemplate } from "giget";
-import { readdir } from "fs/promises";
-import { join } from "path";
-async function processTemplate(options) {
-  const { source, dir, offline, variables = {} } = options;
-  let templateDir;
-  if (source.startsWith("/") || source.startsWith("./") || source.startsWith("../")) {
-    const sourceDir = source.startsWith("/") ? source : join(process.cwd(), source);
-    const copyExitCode = await Bun.spawn(["cp", "-r", sourceDir + "/.", dir], {
-      stdout: "inherit",
-      stderr: "inherit"
-    }).exited;
-    if (copyExitCode !== 0) {
-      throw new Error(`Failed to copy local template from ${sourceDir}`);
-    }
-    templateDir = dir;
-  } else {
-    const result = await downloadTemplate(source, {
-      dir,
-      offline,
-      preferOffline: true,
-      force: true
-    });
-    templateDir = result.dir;
-  }
-  const manifest = await loadTemplateManifest(templateDir);
-  if (manifest?.files || Object.keys(variables).length > 0) {
-    await processTemplateFiles(templateDir, variables, manifest);
-  }
-  if (manifest?.hooks?.postInstall) {
-    await runPostInstallHooks(templateDir, manifest.hooks.postInstall);
-  }
-  return { dir: templateDir, manifest };
-}
-async function loadTemplateManifest(dir) {
-  const possiblePaths = [
-    join(dir, "template.json"),
-    join(dir, ".template.json"),
-    join(dir, "template.yaml"),
-    join(dir, ".template.yaml")
-  ];
-  for (const path of possiblePaths) {
-    const file = Bun.file(path);
-    if (await file.exists()) {
-      const content = await file.text();
-      if (path.endsWith(".json")) {
-        const manifest = JSON.parse(content);
-        const removeExitCode = await Bun.spawn(["rm", "-f", path], {
-          stdout: "ignore",
-          stderr: "ignore"
-        }).exited;
-        if (removeExitCode !== 0) {
-          console.warn(`Warning: failed to remove template manifest ${path}`);
-        }
-        return manifest;
-      }
-    }
-  }
-  return null;
-}
-async function processTemplateFiles(dir, variables, manifest) {
-  const files = await getFilesToProcess(dir, manifest);
-  for (const file of files) {
-    const filePath = join(dir, file);
-    const content = await Bun.file(filePath).text();
-    let processedContent = content;
-    for (const [key, value] of Object.entries(variables)) {
-      processedContent = processedContent.replaceAll(`{{${key}}}`, value).replaceAll(`<%= ${key} %>`, value).replaceAll(`$${key}`, value).replaceAll(`__${key}__`, value);
-    }
-    let newFilePath = filePath;
-    for (const [key, value] of Object.entries(variables)) {
-      newFilePath = newFilePath.replaceAll(`__${key}__`, value);
-    }
-    await Bun.write(newFilePath, processedContent);
-    if (newFilePath !== filePath) {
-      await Bun.spawn(["rm", filePath]).exited;
-    }
-  }
-}
-async function getFilesToProcess(dir, manifest) {
-  if (manifest?.files?.include) {
-    return manifest.files.include;
-  }
-  const files = [];
-  async function walk(currentDir, prefix = "") {
-    const entries = await readdir(currentDir, { withFileTypes: true });
-    for (const entry of entries) {
-      const path = join(prefix, entry.name);
-      if (entry.isDirectory()) {
-        if (!["node_modules", ".git", ".next", "dist", "build"].includes(entry.name)) {
-          await walk(join(currentDir, entry.name), path);
-        }
-      } else {
-        if (!path.match(/^(template\.json|\.template\.json|\.DS_Store|Thumbs\.db)$/) || path === ".gitignore") {
-          files.push(path);
-        }
-      }
-    }
-  }
-  await walk(dir);
-  if (manifest?.files?.exclude) {
-    return files.filter((file) => {
-      return !manifest.files.exclude.some((pattern) => {
-        const regexPattern = pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
-        const regex = new RegExp(`^${regexPattern}$`);
-        return regex.test(file);
-      });
-    });
-  }
-  return files;
-}
-async function runPostInstallHooks(dir, hooks) {
-  for (const hook of hooks) {
-    const proc = Bun.spawn(hook.split(" "), {
-      cwd: dir,
-      stdout: "inherit",
-      stderr: "inherit"
-    });
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-      throw new Error(`Post-install hook failed: ${hook}`);
-    }
-  }
-}
-function resolveTemplateSource(template) {
-  const specialTemplates = {
-    basic: "github:bunli/templates/basic",
-    advanced: "github:bunli/templates/advanced",
-    monorepo: "github:bunli/templates/monorepo"
-  };
-  if (specialTemplates[template]) {
-    return specialTemplates[template];
-  }
-  if (template.startsWith("npm:")) {
-    return template.replace("npm:", "npm:/");
-  }
-  if (template.includes("/") && !template.includes(":")) {
-    return `github:${template}`;
-  }
-  return template;
-}
-function getBundledTemplatePath(name) {
-  return join(import.meta.dir, "..", "templates", name);
-}
-async function isLocalTemplate(template) {
-  if (template.startsWith("file:") || template.startsWith("./") || template.startsWith("../")) {
-    return true;
-  }
-  const bundledPath = getBundledTemplatePath(template);
-  return await Bun.file(join(bundledPath, "package.json")).exists();
-}
-
-// src/steps.ts
-import { existsSync } from "fs";
-import { join as join2 } from "path";
-var LOCKFILE_MAP = [
-  ["bun.lock", "bun"],
-  ["bun.lockb", "bun"],
-  ["pnpm-lock.yaml", "pnpm"],
-  ["yarn.lock", "yarn"],
-  ["package-lock.json", "npm"]
-];
-function detectPackageManager(cwd) {
-  const dir = cwd ?? process.cwd();
-  for (const [lockfile, manager] of LOCKFILE_MAP) {
-    if (existsSync(join2(dir, lockfile))) {
-      return manager;
-    }
-  }
-  const userAgent = process.env.npm_config_user_agent;
-  if (userAgent) {
-    if (userAgent.startsWith("bun"))
-      return "bun";
-    if (userAgent.startsWith("pnpm"))
-      return "pnpm";
-    if (userAgent.startsWith("yarn"))
-      return "yarn";
-    if (userAgent.startsWith("npm"))
-      return "npm";
-  }
-  return "bun";
-}
-function isInGitRepo(cwd) {
-  try {
-    const result = Bun.spawnSync(["git", "rev-parse", "--is-inside-work-tree"], { cwd: cwd ?? process.cwd(), stdout: "ignore", stderr: "ignore" });
-    return result.exitCode === 0;
-  } catch {
-    return false;
-  }
-}
-async function runSteps(dir, steps) {
-  for (const step of steps) {
-    switch (step.type) {
-      case "install":
-        await runInstall(dir);
-        break;
-      case "git-init":
-        await runGitInit(dir, step.commit);
-        break;
-      case "open-editor":
-        await runOpenEditor(dir);
-        break;
-      case "command":
-        await runCommand(step.cmd, step.cwd ?? dir);
-        break;
-    }
-  }
-}
-async function runInstall(cwd) {
-  const pm = detectPackageManager(cwd);
-  const proc = Bun.spawn([pm, "install"], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    const stderr = await new Response(proc.stderr).text();
-    throw new Error(`"${pm} install" exited with code ${exitCode}${stderr ? `: ${stderr.trim()}` : ""}`);
-  }
-}
-async function runGitInit(cwd, commit) {
-  await spawnChecked(["git", "init"], cwd, "git init");
-  if (commit) {
-    await ensureGitIdentity(cwd);
-    await spawnChecked(["git", "add", "."], cwd, "git add");
-    await spawnChecked(["git", "commit", "-m", commit], cwd, "git commit");
-  }
-}
-async function runOpenEditor(cwd) {
-  const editor = process.env.EDITOR || "code";
-  try {
-    const proc = Bun.spawn([editor, cwd], {
-      stdout: "ignore",
-      stderr: "ignore"
-    });
-    const raceResult = await Promise.race([
-      proc.exited.then((code) => ({ kind: "exited", code })),
-      new Promise((resolve) => setTimeout(() => resolve({ kind: "timeout" }), 500))
-    ]);
-    if (raceResult.kind === "exited" && raceResult.code !== 0) {
-      console.warn(`Warning: could not open editor "${editor}" (exit code ${raceResult.code})`);
-    }
-  } catch {
-    console.warn(`Warning: could not open editor "${editor}"`);
-  }
-}
-function getCommandSpawnArgs(cmd, platform = process.platform) {
-  return platform === "win32" ? ["cmd", "/d", "/s", "/c", cmd] : ["sh", "-c", cmd];
-}
-async function runCommand(cmd, cwd) {
-  const proc = Bun.spawn(getCommandSpawnArgs(cmd), {
-    cwd,
-    stdout: "inherit",
-    stderr: "inherit"
-  });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    throw new Error(`Command "${cmd}" exited with code ${exitCode}`);
-  }
-}
-async function ensureGitIdentity(cwd) {
-  const hasName = Bun.spawnSync(["git", "config", "user.name"], { cwd }).exitCode === 0;
-  const hasEmail = Bun.spawnSync(["git", "config", "user.email"], { cwd }).exitCode === 0;
-  if (!hasName) {
-    await spawnChecked(["git", "config", "user.name", "Bunli"], cwd, "git config user.name");
-  }
-  if (!hasEmail) {
-    await spawnChecked(["git", "config", "user.email", "bunli@scaffolded.project"], cwd, "git config user.email");
-  }
-}
-async function spawnChecked(cmd, cwd, label) {
-  const proc = Bun.spawn(cmd, {
-    cwd,
-    stdout: "ignore",
-    stderr: "pipe"
-  });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    const stderr = await new Response(proc.stderr).text();
-    throw new Error(`"${label}" failed with exit code ${exitCode}${stderr ? `: ${stderr.trim()}` : ""}`);
-  }
-}
-
 // ../../node_modules/.bun/better-result@2.7.0/node_modules/better-result/dist/index.mjs
 function dual(arity, body) {
   if (arity === 2)
@@ -454,258 +169,547 @@ var Ok = class Ok2 {
     return this.value;
   }
 };
-var Err = class Err2 {
-  status = "error";
-  constructor(error) {
-    this.error = error;
+var Err = class Err2 {
+  status = "error";
+  constructor(error) {
+    this.error = error;
+  }
+  isOk() {
+    return false;
+  }
+  isErr() {
+    return true;
+  }
+  map(_fn) {
+    return this;
+  }
+  mapError(fn) {
+    return tryOrPanic(() => new Err2(fn(this.error)), "mapError callback threw");
+  }
+  andThen(_fn) {
+    return this;
+  }
+  andThenAsync(_fn) {
+    return Promise.resolve(this);
+  }
+  match(handlers) {
+    return tryOrPanic(() => handlers.err(this.error), "match err handler threw");
+  }
+  unwrap(message) {
+    return panic(message ?? `Unwrap called on Err: ${String(this.error)}`, this.error);
+  }
+  unwrapOr(fallback) {
+    return fallback;
+  }
+  tap(_fn) {
+    return this;
+  }
+  tapAsync(_fn) {
+    return Promise.resolve(this);
+  }
+  *[Symbol.iterator]() {
+    yield this;
+    return panic("Unreachable: Err yielded in Result.gen but generator continued", this.error);
+  }
+};
+function ok(value) {
+  return new Ok(value);
+}
+var isOk = (result) => {
+  return result.status === "ok";
+};
+var err = (error) => new Err(error);
+var isError = (result) => {
+  return result.status === "error";
+};
+var tryFn = (options, config) => {
+  const execute = () => {
+    if (typeof options === "function")
+      try {
+        return ok(options());
+      } catch (cause) {
+        return err(new UnhandledException({ cause }));
+      }
+    try {
+      return ok(options.try());
+    } catch (originalCause) {
+      try {
+        return err(options.catch(originalCause));
+      } catch (catchHandlerError) {
+        throw panic("Result.try catch handler threw", catchHandlerError);
+      }
+    }
+  };
+  const times = config?.retry?.times ?? 0;
+  let result = execute();
+  for (let retry = 0;retry < times && result.status === "error"; retry++)
+    result = execute();
+  return result;
+};
+var tryPromise = async (options, config) => {
+  const execute = async () => {
+    if (typeof options === "function")
+      try {
+        return ok(await options());
+      } catch (cause) {
+        return err(new UnhandledException({ cause }));
+      }
+    try {
+      return ok(await options.try());
+    } catch (originalCause) {
+      try {
+        return err(await options.catch(originalCause));
+      } catch (catchHandlerError) {
+        throw panic("Result.tryPromise catch handler threw", catchHandlerError);
+      }
+    }
+  };
+  const retry = config?.retry;
+  if (!retry)
+    return execute();
+  const getDelay = (retryAttempt) => {
+    switch (retry.backoff) {
+      case "constant":
+        return retry.delayMs;
+      case "linear":
+        return retry.delayMs * (retryAttempt + 1);
+      case "exponential":
+        return retry.delayMs * 2 ** retryAttempt;
+    }
+  };
+  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  let result = await execute();
+  const shouldRetryFn = retry.shouldRetry ?? (() => true);
+  for (let attempt = 0;attempt < retry.times; attempt++) {
+    if (result.status !== "error")
+      break;
+    const error = result.error;
+    if (!tryOrPanic(() => shouldRetryFn(error), "shouldRetry predicate threw"))
+      break;
+    await sleep(getDelay(attempt));
+    result = await execute();
+  }
+  return result;
+};
+var map = dual(2, (result, fn) => {
+  return result.map(fn);
+});
+var mapError = dual(2, (result, fn) => {
+  return result.mapError(fn);
+});
+var andThen = dual(2, (result, fn) => {
+  return result.andThen(fn);
+});
+var andThenAsync = dual(2, (result, fn) => {
+  return result.andThenAsync(fn);
+});
+var match = dual(2, (result, handlers) => {
+  return result.match(handlers);
+});
+var tap = dual(2, (result, fn) => {
+  return result.tap(fn);
+});
+var tapAsync = dual(2, (result, fn) => {
+  return result.tapAsync(fn);
+});
+var unwrap = (result, message) => {
+  return result.unwrap(message);
+};
+function assertIsResult(value) {
+  if (value !== null && typeof value === "object" && "status" in value && (value.status === "ok" || value.status === "error"))
+    return;
+  return panic("Result.gen body must return Result.ok() or Result.err(), got: " + (value === null ? "null" : typeof value === "object" ? JSON.stringify(value) : String(value)));
+}
+var unwrapOr = dual(2, (result, fallback) => {
+  return result.unwrapOr(fallback);
+});
+var gen = (body, thisArg) => {
+  const iterator = body.call(thisArg);
+  if (Symbol.asyncIterator in iterator)
+    return (async () => {
+      const asyncIter = iterator;
+      let state$1;
+      try {
+        state$1 = await asyncIter.next();
+      } catch (cause) {
+        throw panic("generator body threw", cause);
+      }
+      assertIsResult(state$1.value);
+      if (!state$1.done)
+        try {
+          await asyncIter.return?.(undefined);
+        } catch (cause) {
+          throw panic("generator cleanup threw", cause);
+        }
+      return state$1.value;
+    })();
+  const syncIter = iterator;
+  let state;
+  try {
+    state = syncIter.next();
+  } catch (cause) {
+    throw panic("generator body threw", cause);
+  }
+  assertIsResult(state.value);
+  if (!state.done)
+    try {
+      syncIter.return?.(undefined);
+    } catch (cause) {
+      throw panic("generator cleanup threw", cause);
+    }
+  return state.value;
+};
+async function* resultAwait(promise) {
+  return yield* await promise;
+}
+function isSerializedResult(obj) {
+  return obj !== null && typeof obj === "object" && "status" in obj && (obj.status === "ok" && ("value" in obj) || obj.status === "error" && ("error" in obj));
+}
+var serialize = (result) => {
+  return result.status === "ok" ? {
+    status: "ok",
+    value: result.value
+  } : {
+    status: "error",
+    error: result.error
+  };
+};
+var deserialize = (value) => {
+  if (isSerializedResult(value))
+    return value.status === "ok" ? new Ok(value.value) : new Err(value.error);
+  return err(new ResultDeserializationError({ value }));
+};
+var hydrate = (value) => {
+  return deserialize(value);
+};
+var partition = (results) => {
+  const oks = [];
+  const errs = [];
+  for (const r of results)
+    if (r.status === "ok")
+      oks.push(r.value);
+    else
+      errs.push(r.error);
+  return [oks, errs];
+};
+var flatten = (result) => {
+  if (result.status === "ok")
+    return result.value;
+  return result;
+};
+var Result = {
+  ok,
+  isOk,
+  err,
+  isError,
+  try: tryFn,
+  tryPromise,
+  map,
+  mapError,
+  andThen,
+  andThenAsync,
+  match,
+  tap,
+  tapAsync,
+  unwrap,
+  unwrapOr,
+  gen,
+  await: resultAwait,
+  serialize,
+  deserialize,
+  hydrate,
+  partition,
+  flatten
+};
+
+// src/steps.ts
+import { existsSync } from "fs";
+import { join } from "path";
+var LOCKFILE_MAP = [
+  ["bun.lock", "bun"],
+  ["bun.lockb", "bun"],
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["package-lock.json", "npm"]
+];
+function detectPackageManager(cwd) {
+  const dir = cwd ?? process.cwd();
+  for (const [lockfile, manager] of LOCKFILE_MAP) {
+    if (existsSync(join(dir, lockfile))) {
+      return manager;
+    }
   }
-  isOk() {
+  const userAgent = process.env.npm_config_user_agent;
+  if (userAgent) {
+    if (userAgent.startsWith("bun"))
+      return "bun";
+    if (userAgent.startsWith("pnpm"))
+      return "pnpm";
+    if (userAgent.startsWith("yarn"))
+      return "yarn";
+    if (userAgent.startsWith("npm"))
+      return "npm";
+  }
+  return "bun";
+}
+function isInGitRepo(cwd) {
+  try {
+    const result = Bun.spawnSync(["git", "rev-parse", "--is-inside-work-tree"], {
+      cwd: cwd ?? process.cwd(),
+      stdout: "ignore",
+      stderr: "ignore"
+    });
+    return result.exitCode === 0;
+  } catch {
     return false;
   }
-  isErr() {
-    return true;
+}
+async function runSteps(dir, steps) {
+  for (const step of steps) {
+    switch (step.type) {
+      case "install":
+        await runInstall(dir);
+        break;
+      case "git-init":
+        await runGitInit(dir, step.commit);
+        break;
+      case "open-editor":
+        await runOpenEditor(dir);
+        break;
+      case "command":
+        await runCommand(step.cmd, step.cwd ?? dir);
+        break;
+    }
   }
-  map(_fn) {
-    return this;
+}
+async function runInstall(cwd) {
+  const pm = detectPackageManager(cwd);
+  const proc = Bun.spawn([pm, "install"], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`"${pm} install" exited with code ${exitCode}${stderr ? `: ${stderr.trim()}` : ""}`);
   }
-  mapError(fn) {
-    return tryOrPanic(() => new Err2(fn(this.error)), "mapError callback threw");
+}
+async function runGitInit(cwd, commit) {
+  await spawnChecked(["git", "init"], cwd, "git init");
+  if (commit) {
+    await ensureGitIdentity(cwd);
+    await spawnChecked(["git", "add", "."], cwd, "git add");
+    await spawnChecked(["git", "commit", "-m", commit], cwd, "git commit");
   }
-  andThen(_fn) {
-    return this;
+}
+async function runOpenEditor(cwd) {
+  const editor = process.env.EDITOR || "code";
+  try {
+    const proc = Bun.spawn([editor, cwd], {
+      stdout: "ignore",
+      stderr: "ignore"
+    });
+    const raceResult = await Promise.race([
+      proc.exited.then((code) => ({ kind: "exited", code })),
+      new Promise((resolve) => setTimeout(() => resolve({ kind: "timeout" }), 500))
+    ]);
+    if (raceResult.kind === "exited" && raceResult.code !== 0) {
+      console.warn(`Warning: could not open editor "${editor}" (exit code ${raceResult.code})`);
+    }
+  } catch {
+    console.warn(`Warning: could not open editor "${editor}"`);
   }
-  andThenAsync(_fn) {
-    return Promise.resolve(this);
+}
+function getCommandSpawnArgs(cmd, platform = process.platform) {
+  return platform === "win32" ? ["cmd", "/d", "/s", "/c", cmd] : ["sh", "-c", cmd];
+}
+async function runCommand(cmd, cwd) {
+  const proc = Bun.spawn(getCommandSpawnArgs(cmd), {
+    cwd,
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error(`Command "${cmd}" exited with code ${exitCode}`);
   }
-  match(handlers) {
-    return tryOrPanic(() => handlers.err(this.error), "match err handler threw");
+}
+async function ensureGitIdentity(cwd) {
+  const hasName = Bun.spawnSync(["git", "config", "user.name"], { cwd }).exitCode === 0;
+  const hasEmail = Bun.spawnSync(["git", "config", "user.email"], { cwd }).exitCode === 0;
+  if (!hasName) {
+    await spawnChecked(["git", "config", "user.name", "Bunli"], cwd, "git config user.name");
   }
-  unwrap(message) {
-    return panic(message ?? `Unwrap called on Err: ${String(this.error)}`, this.error);
+  if (!hasEmail) {
+    await spawnChecked(["git", "config", "user.email", "bunli@scaffolded.project"], cwd, "git config user.email");
   }
-  unwrapOr(fallback) {
-    return fallback;
+}
+async function spawnChecked(cmd, cwd, label) {
+  const proc = Bun.spawn(cmd, {
+    cwd,
+    stdout: "ignore",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`"${label}" failed with exit code ${exitCode}${stderr ? `: ${stderr.trim()}` : ""}`);
   }
-  tap(_fn) {
-    return this;
+}
+
+// src/template-engine.ts
+import { readdir } from "fs/promises";
+import { join as join2 } from "path";
+import { downloadTemplate } from "giget";
+async function processTemplate(options) {
+  const { source, dir, offline, variables = {} } = options;
+  let templateDir;
+  if (source.startsWith("/") || source.startsWith("./") || source.startsWith("../")) {
+    const sourceDir = source.startsWith("/") ? source : join2(process.cwd(), source);
+    const copyExitCode = await Bun.spawn(["cp", "-r", sourceDir + "/.", dir], {
+      stdout: "inherit",
+      stderr: "inherit"
+    }).exited;
+    if (copyExitCode !== 0) {
+      throw new Error(`Failed to copy local template from ${sourceDir}`);
+    }
+    templateDir = dir;
+  } else {
+    const result = await downloadTemplate(source, {
+      dir,
+      offline,
+      preferOffline: true,
+      force: true
+    });
+    templateDir = result.dir;
   }
-  tapAsync(_fn) {
-    return Promise.resolve(this);
+  const manifest = await loadTemplateManifest(templateDir);
+  if (manifest?.files || Object.keys(variables).length > 0) {
+    await processTemplateFiles(templateDir, variables, manifest);
   }
-  *[Symbol.iterator]() {
-    yield this;
-    return panic("Unreachable: Err yielded in Result.gen but generator continued", this.error);
+  if (manifest?.hooks?.postInstall) {
+    await runPostInstallHooks(templateDir, manifest.hooks.postInstall);
   }
-};
-function ok(value) {
-  return new Ok(value);
+  return { dir: templateDir, manifest };
 }
-var isOk = (result) => {
-  return result.status === "ok";
-};
-var err = (error) => new Err(error);
-var isError = (result) => {
-  return result.status === "error";
-};
-var tryFn = (options, config) => {
-  const execute = () => {
-    if (typeof options === "function")
-      try {
-        return ok(options());
-      } catch (cause) {
-        return err(new UnhandledException({ cause }));
-      }
-    try {
-      return ok(options.try());
-    } catch (originalCause) {
-      try {
-        return err(options.catch(originalCause));
-      } catch (catchHandlerError) {
-        throw panic("Result.try catch handler threw", catchHandlerError);
+async function loadTemplateManifest(dir) {
+  const possiblePaths = [
+    join2(dir, "template.json"),
+    join2(dir, ".template.json"),
+    join2(dir, "template.yaml"),
+    join2(dir, ".template.yaml")
+  ];
+  for (const path of possiblePaths) {
+    const file = Bun.file(path);
+    if (await file.exists()) {
+      const content = await file.text();
+      if (path.endsWith(".json")) {
+        const manifest = JSON.parse(content);
+        const removeExitCode = await Bun.spawn(["rm", "-f", path], {
+          stdout: "ignore",
+          stderr: "ignore"
+        }).exited;
+        if (removeExitCode !== 0) {
+          console.warn(`Warning: failed to remove template manifest ${path}`);
+        }
+        return manifest;
       }
     }
-  };
-  const times = config?.retry?.times ?? 0;
-  let result = execute();
-  for (let retry = 0;retry < times && result.status === "error"; retry++)
-    result = execute();
-  return result;
-};
-var tryPromise = async (options, config) => {
-  const execute = async () => {
-    if (typeof options === "function")
-      try {
-        return ok(await options());
-      } catch (cause) {
-        return err(new UnhandledException({ cause }));
-      }
-    try {
-      return ok(await options.try());
-    } catch (originalCause) {
-      try {
-        return err(await options.catch(originalCause));
-      } catch (catchHandlerError) {
-        throw panic("Result.tryPromise catch handler threw", catchHandlerError);
-      }
+  }
+  return null;
+}
+async function processTemplateFiles(dir, variables, manifest) {
+  const files = await getFilesToProcess(dir, manifest);
+  for (const file of files) {
+    const filePath = join2(dir, file);
+    const content = await Bun.file(filePath).text();
+    let processedContent = content;
+    for (const [key, value] of Object.entries(variables)) {
+      processedContent = processedContent.replaceAll(`{{${key}}}`, value).replaceAll(`<%= ${key} %>`, value).replaceAll(`$${key}`, value).replaceAll(`__${key}__`, value);
     }
-  };
-  const retry = config?.retry;
-  if (!retry)
-    return execute();
-  const getDelay = (retryAttempt) => {
-    switch (retry.backoff) {
-      case "constant":
-        return retry.delayMs;
-      case "linear":
-        return retry.delayMs * (retryAttempt + 1);
-      case "exponential":
-        return retry.delayMs * 2 ** retryAttempt;
+    let newFilePath = filePath;
+    for (const [key, value] of Object.entries(variables)) {
+      newFilePath = newFilePath.replaceAll(`__${key}__`, value);
+    }
+    await Bun.write(newFilePath, processedContent);
+    if (newFilePath !== filePath) {
+      await Bun.spawn(["rm", filePath]).exited;
     }
-  };
-  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-  let result = await execute();
-  const shouldRetryFn = retry.shouldRetry ?? (() => true);
-  for (let attempt = 0;attempt < retry.times; attempt++) {
-    if (result.status !== "error")
-      break;
-    const error = result.error;
-    if (!tryOrPanic(() => shouldRetryFn(error), "shouldRetry predicate threw"))
-      break;
-    await sleep(getDelay(attempt));
-    result = await execute();
   }
-  return result;
-};
-var map = dual(2, (result, fn) => {
-  return result.map(fn);
-});
-var mapError = dual(2, (result, fn) => {
-  return result.mapError(fn);
-});
-var andThen = dual(2, (result, fn) => {
-  return result.andThen(fn);
-});
-var andThenAsync = dual(2, (result, fn) => {
-  return result.andThenAsync(fn);
-});
-var match = dual(2, (result, handlers) => {
-  return result.match(handlers);
-});
-var tap = dual(2, (result, fn) => {
-  return result.tap(fn);
-});
-var tapAsync = dual(2, (result, fn) => {
-  return result.tapAsync(fn);
-});
-var unwrap = (result, message) => {
-  return result.unwrap(message);
-};
-function assertIsResult(value) {
-  if (value !== null && typeof value === "object" && "status" in value && (value.status === "ok" || value.status === "error"))
-    return;
-  return panic("Result.gen body must return Result.ok() or Result.err(), got: " + (value === null ? "null" : typeof value === "object" ? JSON.stringify(value) : String(value)));
 }
-var unwrapOr = dual(2, (result, fallback) => {
-  return result.unwrapOr(fallback);
-});
-var gen = (body, thisArg) => {
-  const iterator = body.call(thisArg);
-  if (Symbol.asyncIterator in iterator)
-    return (async () => {
-      const asyncIter = iterator;
-      let state$1;
-      try {
-        state$1 = await asyncIter.next();
-      } catch (cause) {
-        throw panic("generator body threw", cause);
-      }
-      assertIsResult(state$1.value);
-      if (!state$1.done)
-        try {
-          await asyncIter.return?.(undefined);
-        } catch (cause) {
-          throw panic("generator cleanup threw", cause);
-        }
-      return state$1.value;
-    })();
-  const syncIter = iterator;
-  let state;
-  try {
-    state = syncIter.next();
-  } catch (cause) {
-    throw panic("generator body threw", cause);
+async function getFilesToProcess(dir, manifest) {
+  if (manifest?.files?.include) {
+    return manifest.files.include;
   }
-  assertIsResult(state.value);
-  if (!state.done)
-    try {
-      syncIter.return?.(undefined);
-    } catch (cause) {
-      throw panic("generator cleanup threw", cause);
+  const files = [];
+  async function walk(currentDir, prefix = "") {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const path = join2(prefix, entry.name);
+      if (entry.isDirectory()) {
+        if (!["node_modules", ".git", ".next", "dist", "build"].includes(entry.name)) {
+          await walk(join2(currentDir, entry.name), path);
+        }
+      } else {
+        if (!path.match(/^(template\.json|\.template\.json|\.DS_Store|Thumbs\.db)$/) || path === ".gitignore") {
+          files.push(path);
+        }
+      }
     }
-  return state.value;
-};
-async function* resultAwait(promise) {
-  return yield* await promise;
+  }
+  await walk(dir);
+  if (manifest?.files?.exclude) {
+    return files.filter((file) => {
+      return !manifest.files.exclude.some((pattern) => {
+        const regexPattern = pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(file);
+      });
+    });
+  }
+  return files;
 }
-function isSerializedResult(obj) {
-  return obj !== null && typeof obj === "object" && "status" in obj && (obj.status === "ok" && ("value" in obj) || obj.status === "error" && ("error" in obj));
+async function runPostInstallHooks(dir, hooks) {
+  for (const hook of hooks) {
+    const proc = Bun.spawn(hook.split(" "), {
+      cwd: dir,
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      throw new Error(`Post-install hook failed: ${hook}`);
+    }
+  }
 }
-var serialize = (result) => {
-  return result.status === "ok" ? {
-    status: "ok",
-    value: result.value
-  } : {
-    status: "error",
-    error: result.error
+function resolveTemplateSource(template) {
+  const specialTemplates = {
+    basic: "github:bunli/templates/basic",
+    advanced: "github:bunli/templates/advanced",
+    monorepo: "github:bunli/templates/monorepo"
   };
-};
-var deserialize = (value) => {
-  if (isSerializedResult(value))
-    return value.status === "ok" ? new Ok(value.value) : new Err(value.error);
-  return err(new ResultDeserializationError({ value }));
-};
-var hydrate = (value) => {
-  return deserialize(value);
-};
-var partition = (results) => {
-  const oks = [];
-  const errs = [];
-  for (const r of results)
-    if (r.status === "ok")
-      oks.push(r.value);
-    else
-      errs.push(r.error);
-  return [oks, errs];
-};
-var flatten = (result) => {
-  if (result.status === "ok")
-    return result.value;
-  return result;
-};
-var Result = {
-  ok,
-  isOk,
-  err,
-  isError,
-  try: tryFn,
-  tryPromise,
-  map,
-  mapError,
-  andThen,
-  andThenAsync,
-  match,
-  tap,
-  tapAsync,
-  unwrap,
-  unwrapOr,
-  gen,
-  await: resultAwait,
-  serialize,
-  deserialize,
-  hydrate,
-  partition,
-  flatten
-};
+  if (specialTemplates[template]) {
+    return specialTemplates[template];
+  }
+  if (template.startsWith("npm:")) {
+    return template.replace("npm:", "npm:/");
+  }
+  if (template.includes("/") && !template.includes(":")) {
+    return `github:${template}`;
+  }
+  return template;
+}
+function getBundledTemplatePath(name) {
+  return join2(import.meta.dir, "..", "templates", name);
+}
+async function isLocalTemplate(template) {
+  if (template.startsWith("file:") || template.startsWith("./") || template.startsWith("../")) {
+    return true;
+  }
+  const bundledPath = getBundledTemplatePath(template);
+  return await Bun.file(join2(bundledPath, "package.json")).exists();
+}
 
 // src/create-project.ts
 var toErrorMessage = (error) => error instanceof Error ? error.message : String(error);
@@ -764,7 +768,9 @@ async function createProject(options) {
   const { name, dir, template, git, install, prompt, spinner, colors, shell, offline } = options;
   const directoryCheck = await shell`test -d ${dir}`.nothrow();
   if (directoryCheck.exitCode === 0) {
-    const overwrite = await prompt.confirm(`Directory ${dir} already exists. Overwrite?`, { default: false });
+    const overwrite = await prompt.confirm(`Directory ${dir} already exists. Overwrite?`, {
+      default: false
+    });
     if (!overwrite) {
       return Result.err(new UserCancelledError("Cancelled"));
     }