create-bunli 0.8.0 → 0.8.2

package/dist/cli.js

@@ -3,421 +3,135 @@
 
 // src/cli.ts
 import { createCLI, defineCommand, option } from "@bunli/core";
-import { z } from "zod";
 
-// 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;
+// ../../node_modules/.bun/better-result@2.7.0/node_modules/better-result/dist/index.mjs
+function dual(arity, body) {
+  if (arity === 2)
+    return (...args) => {
+      if (args.length >= 2)
+        return body(args[0], args[1]);
+      return (self) => body(self, args[0]);
+    };
+  if (arity === 3)
+    return (...args) => {
+      if (args.length >= 3)
+        return body(args[0], args[1], args[2]);
+      return (self) => body(self, args[0], args[1]);
+    };
+  if (arity === 4)
+    return (...args) => {
+      if (args.length >= 4)
+        return body(args[0], args[1], args[2], args[3]);
+      return (self) => body(self, args[0], args[1], args[2]);
+    };
+  return (...args) => {
+    if (args.length >= arity)
+      return body(...args);
+    return (self) => body(self, ...args);
+  };
 }
-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;
+var serializeCause = (cause) => {
+  if (cause instanceof Error)
+    return {
+      name: cause.name,
+      message: cause.message,
+      stack: cause.stack
+    };
+  return cause;
+};
+var isAnyTaggedError = (value) => {
+  return value instanceof Error && "_tag" in value && typeof value._tag === "string";
+};
+var TaggedError = Object.assign((tag) => () => {
+
+  class Base extends Error {
+    _tag = tag;
+    static is(value) {
+      return value instanceof Base;
     }
-  }
-}
-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);
-        }
+    constructor(args) {
+      const message = args && "message" in args && typeof args.message === "string" ? args.message : undefined;
+      const cause = args && "cause" in args ? args.cause : undefined;
+      super(message, cause !== undefined ? { cause } : undefined);
+      if (args)
+        Object.assign(this, args);
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = tag;
+      if (cause instanceof Error && cause.stack) {
+        const indented = cause.stack.replace(/\n/g, `
+  `);
+        this.stack = `${this.stack}
+Caused by: ${indented}`;
       }
     }
+    toJSON() {
+      return {
+        ...this,
+        _tag: this._tag,
+        name: this.name,
+        message: this.message,
+        cause: serializeCause(this.cause),
+        stack: this.stack
+      };
+    }
   }
-  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 Base;
+}, { is: isAnyTaggedError });
+var matchError = dual(2, (err$1, handlers) => {
+  const handler = handlers[err$1._tag];
+  return handler(err$1);
+});
+var matchErrorPartial = dual(3, (err$1, handlers, fallback) => {
+  const handler = handlers[err$1._tag];
+  if (typeof handler === "function")
+    return handler(err$1);
+  return fallback(err$1);
+});
+var UnhandledException = class extends TaggedError("UnhandledException")() {
+  constructor(args) {
+    const message = args.cause instanceof Error ? `Unhandled exception: ${args.cause.message}` : `Unhandled exception: ${String(args.cause)}`;
+    super({
+      message,
+      cause: args.cause
     });
   }
-  return files;
-}
-async function runPostInstallHooks(dir, hooks) {
-  for (const hook of hooks) {
-    const proc = Bun.spawn(hook.split(" "), {
-      cwd: dir,
-      stdout: "inherit",
-      stderr: "inherit"
+};
+var Panic = class extends TaggedError("Panic")() {
+};
+var ResultDeserializationError = class extends TaggedError("ResultDeserializationError")() {
+  constructor(args) {
+    super({
+      message: `Failed to deserialize value as Result: expected { status: "ok", value } or { status: "error", error }`,
+      value: args.value
     });
-    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];
+};
+var panic = (message, cause) => {
+  throw new Panic({
+    message,
+    cause
+  });
+};
+var tryOrPanic = (fn, message) => {
+  try {
+    return fn();
+  } catch (cause) {
+    throw panic(message, cause);
   }
-  if (template.startsWith("npm:")) {
-    return template.replace("npm:", "npm:/");
+};
+var tryOrPanicAsync = async (fn, message) => {
+  try {
+    return await fn();
+  } catch (cause) {
+    throw panic(message, cause);
   }
-  if (template.includes("/") && !template.includes(":")) {
-    return `github:${template}`;
+};
+var Ok = class Ok2 {
+  status = "ok";
+  constructor(value) {
+    this.value = value;
   }
-  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)
-    return (...args) => {
-      if (args.length >= 2)
-        return body(args[0], args[1]);
-      return (self) => body(self, args[0]);
-    };
-  if (arity === 3)
-    return (...args) => {
-      if (args.length >= 3)
-        return body(args[0], args[1], args[2]);
-      return (self) => body(self, args[0], args[1]);
-    };
-  if (arity === 4)
-    return (...args) => {
-      if (args.length >= 4)
-        return body(args[0], args[1], args[2], args[3]);
-      return (self) => body(self, args[0], args[1], args[2]);
-    };
-  return (...args) => {
-    if (args.length >= arity)
-      return body(...args);
-    return (self) => body(self, ...args);
-  };
-}
-var serializeCause = (cause) => {
-  if (cause instanceof Error)
-    return {
-      name: cause.name,
-      message: cause.message,
-      stack: cause.stack
-    };
-  return cause;
-};
-var isAnyTaggedError = (value) => {
-  return value instanceof Error && "_tag" in value && typeof value._tag === "string";
-};
-var TaggedError = Object.assign((tag) => () => {
-
-  class Base extends Error {
-    _tag = tag;
-    static is(value) {
-      return value instanceof Base;
-    }
-    constructor(args) {
-      const message = args && "message" in args && typeof args.message === "string" ? args.message : undefined;
-      const cause = args && "cause" in args ? args.cause : undefined;
-      super(message, cause !== undefined ? { cause } : undefined);
-      if (args)
-        Object.assign(this, args);
-      Object.setPrototypeOf(this, new.target.prototype);
-      this.name = tag;
-      if (cause instanceof Error && cause.stack) {
-        const indented = cause.stack.replace(/\n/g, `
-  `);
-        this.stack = `${this.stack}
-Caused by: ${indented}`;
-      }
-    }
-    toJSON() {
-      return {
-        ...this,
-        _tag: this._tag,
-        name: this.name,
-        message: this.message,
-        cause: serializeCause(this.cause),
-        stack: this.stack
-      };
-    }
-  }
-  return Base;
-}, { is: isAnyTaggedError });
-var matchError = dual(2, (err$1, handlers) => {
-  const handler = handlers[err$1._tag];
-  return handler(err$1);
-});
-var matchErrorPartial = dual(3, (err$1, handlers, fallback) => {
-  const handler = handlers[err$1._tag];
-  if (typeof handler === "function")
-    return handler(err$1);
-  return fallback(err$1);
-});
-var UnhandledException = class extends TaggedError("UnhandledException")() {
-  constructor(args) {
-    const message = args.cause instanceof Error ? `Unhandled exception: ${args.cause.message}` : `Unhandled exception: ${String(args.cause)}`;
-    super({
-      message,
-      cause: args.cause
-    });
-  }
-};
-var Panic = class extends TaggedError("Panic")() {
-};
-var ResultDeserializationError = class extends TaggedError("ResultDeserializationError")() {
-  constructor(args) {
-    super({
-      message: `Failed to deserialize value as Result: expected { status: "ok", value } or { status: "error", error }`,
-      value: args.value
-    });
-  }
-};
-var panic = (message, cause) => {
-  throw new Panic({
-    message,
-    cause
-  });
-};
-var tryOrPanic = (fn, message) => {
-  try {
-    return fn();
-  } catch (cause) {
-    throw panic(message, cause);
-  }
-};
-var tryOrPanicAsync = async (fn, message) => {
-  try {
-    return await fn();
-  } catch (cause) {
-    throw panic(message, cause);
-  }
-};
-var Ok = class Ok2 {
-  status = "ok";
-  constructor(value) {
-    this.value = value;
-  }
-  isOk() {
+  isOk() {
     return true;
   }
   isErr() {
@@ -554,164 +268,459 @@ var tryPromise = async (options, config) => {
         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 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/cli.ts
+import { z } from "zod";
+
+// src/create.ts
+import path from "path";
+
+// 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;
+    }
+  }
+  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()}` : ""}`);
+  }
+}
+
+// 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;
+  }
+  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 = [
+    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;
+      }
+    }
+  }
+  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);
+    }
+    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);
@@ -770,7 +779,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"));
     }
@@ -844,10 +855,11 @@ async function createProject(options) {
 }
 
 // src/create.ts
-import path from "path";
 class InvalidProjectNameError extends TaggedError("InvalidProjectNameError")() {
   constructor(name) {
-    super({ message: `Project name "${name}" must only contain lowercase letters, numbers, and hyphens` });
+    super({
+      message: `Project name "${name}" must only contain lowercase letters, numbers, and hyphens`
+    });
   }
 }
 
@@ -941,11 +953,28 @@ async function run() {
     description: "Create a new Bunli CLI project",
     options: {
       name: option(z.string().optional(), { description: "Project name" }),
-      template: option(z.string().default("basic"), { short: "t", description: "Project template (basic, advanced, monorepo, or github:user/repo)" }),
-      dir: option(z.string().optional(), { short: "d", description: "Directory to create project in" }),
-      git: option(z.boolean().default(true), { short: "g", description: "Initialize git repository", argumentKind: "flag" }),
-      install: option(z.boolean().default(true), { short: "i", description: "Install dependencies", argumentKind: "flag" }),
-      offline: option(z.boolean().default(false), { description: "Use cached templates when available", argumentKind: "flag" })
+      template: option(z.string().default("basic"), {
+        short: "t",
+        description: "Project template (basic, advanced, monorepo, or github:user/repo)"
+      }),
+      dir: option(z.string().optional(), {
+        short: "d",
+        description: "Directory to create project in"
+      }),
+      git: option(z.boolean().default(true), {
+        short: "g",
+        description: "Initialize git repository",
+        argumentKind: "flag"
+      }),
+      install: option(z.boolean().default(true), {
+        short: "i",
+        description: "Install dependencies",
+        argumentKind: "flag"
+      }),
+      offline: option(z.boolean().default(false), {
+        description: "Use cached templates when available",
+        argumentKind: "flag"
+      })
     },
     handler: async (context) => {
       const result = await create(context);