create-bunli 0.5.4 → 0.6.0

package/dist/create-project.d.ts

@@ -1,5 +1,6 @@
 import type { BunliUtils } from '@bunli/utils';
 import type { CreateOptions } from './types.js';
+import { Result } from 'better-result';
 interface CreateProjectOptions extends CreateOptions {
     name: string;
     dir: string;
@@ -9,5 +10,27 @@ interface CreateProjectOptions extends CreateOptions {
     colors: BunliUtils['colors'];
     shell: typeof Bun.$;
 }
-export declare function createProject(options: CreateProjectOptions): Promise<void>;
+declare const UserCancelledError_base: import("better-result").TaggedErrorClass<"UserCancelledError", {
+    message: string;
+}>;
+export declare class UserCancelledError extends UserCancelledError_base {
+    constructor(message: string);
+}
+declare const ShellCommandError_base: import("better-result").TaggedErrorClass<"ShellCommandError", {
+    message: string;
+    command: string;
+    output: string;
+}>;
+declare class ShellCommandError extends ShellCommandError_base {
+    constructor(command: string, output: string);
+}
+declare const TemplateProcessingError_base: import("better-result").TaggedErrorClass<"TemplateProcessingError", {
+    message: string;
+    cause: unknown;
+}>;
+declare class TemplateProcessingError extends TemplateProcessingError_base {
+    constructor(cause: unknown);
+}
+export type CreateProjectError = UserCancelledError | ShellCommandError | TemplateProcessingError;
+export declare function createProject(options: CreateProjectOptions): Promise<Result<void, CreateProjectError>>;
 export {};

package/dist/create.d.ts

@@ -1,4 +1,6 @@
 import type { HandlerArgs } from '@bunli/core';
+import { type CreateProjectError } from './create-project.js';
+import { Result } from 'better-result';
 interface CreateOptions {
     name?: string;
     template: string;
@@ -7,5 +9,18 @@ interface CreateOptions {
     install: boolean;
     offline?: boolean;
 }
-export declare function create(context: HandlerArgs<CreateOptions>): Promise<void>;
+declare const InvalidProjectNameError_base: import("better-result").TaggedErrorClass<"InvalidProjectNameError", {
+    message: string;
+}>;
+declare class InvalidProjectNameError extends InvalidProjectNameError_base {
+    constructor(name: string);
+}
+declare const UserCancelledError_base: import("better-result").TaggedErrorClass<"UserCancelledError", {
+    message: string;
+}>;
+export declare class UserCancelledError extends UserCancelledError_base {
+    constructor(message: string);
+}
+export type CreateCommandError = InvalidProjectNameError | UserCancelledError | CreateProjectError;
+export declare function create(context: HandlerArgs<CreateOptions>): Promise<Result<void, CreateCommandError>>;
 export {};

package/dist/index.js

@@ -8,10 +8,13 @@ async function processTemplate(options) {
   let templateDir;
   if (source.startsWith("/") || source.startsWith("./") || source.startsWith("../")) {
     const sourceDir = source.startsWith("/") ? source : join(process.cwd(), source);
-    await Bun.spawn(["cp", "-r", sourceDir + "/.", dir], {
+    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, {
@@ -44,12 +47,13 @@ async function loadTemplateManifest(dir) {
       const content = await file.text();
       if (path.endsWith(".json")) {
         const manifest = JSON.parse(content);
-        try {
-          await Bun.spawn(["rm", "-f", path], {
-            stdout: "ignore",
-            stderr: "ignore"
-          }).exited;
-        } catch {}
+        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;
       }
     }
@@ -114,7 +118,10 @@ async function runPostInstallHooks(dir, hooks) {
       stdout: "inherit",
       stderr: "inherit"
     });
-    await proc.exited;
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      throw new Error(`Post-install hook failed: ${hook}`);
+    }
   }
 }
 function resolveTemplateSource(template) {
@@ -145,79 +152,541 @@ async function isLocalTemplate(template) {
   return await Bun.file(join(bundledPath, "package.json")).exists();
 }
 
+// ../../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() {
+    return true;
+  }
+  isErr() {
+    return false;
+  }
+  map(fn) {
+    return tryOrPanic(() => new Ok2(fn(this.value)), "map callback threw");
+  }
+  mapError(_fn) {
+    return this;
+  }
+  andThen(fn) {
+    return tryOrPanic(() => fn(this.value), "andThen callback threw");
+  }
+  andThenAsync(fn) {
+    return tryOrPanicAsync(() => fn(this.value), "andThenAsync callback threw");
+  }
+  match(handlers) {
+    return tryOrPanic(() => handlers.ok(this.value), "match ok handler threw");
+  }
+  unwrap(_message) {
+    return this.value;
+  }
+  unwrapOr(_fallback) {
+    return this.value;
+  }
+  tap(fn) {
+    return tryOrPanic(() => {
+      fn(this.value);
+      return this;
+    }, "tap callback threw");
+  }
+  tapAsync(fn) {
+    return tryOrPanicAsync(async () => {
+      await fn(this.value);
+      return this;
+    }, "tapAsync callback threw");
+  }
+  *[Symbol.iterator]() {
+    return this.value;
+  }
+};
+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/create-project.ts
+var toErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+var tryAsync = (fn, mapError2) => Result.tryPromise({ try: fn, catch: mapError2 });
+
+class UserCancelledError extends TaggedError("UserCancelledError")() {
+  constructor(message) {
+    super({ message });
+  }
+}
+
+class ShellCommandError extends TaggedError("ShellCommandError")() {
+  constructor(command, output) {
+    super({
+      message: `Command failed (${command}): ${output}`,
+      command,
+      output
+    });
+  }
+}
+
+class TemplateProcessingError extends TaggedError("TemplateProcessingError")() {
+  constructor(cause) {
+    super({ message: `Failed to process template: ${toErrorMessage(cause)}`, cause });
+  }
+}
 async function createProject(options) {
   const { name, dir, template, git, install, prompt, spinner, colors, shell, offline } = options;
-  try {
-    await shell`test -d ${dir}`.quiet();
+  const directoryCheck = await shell`test -d ${dir}`.nothrow();
+  if (directoryCheck.exitCode === 0) {
     const overwrite = await prompt.confirm(`Directory ${dir} already exists. Overwrite?`, { default: false });
     if (!overwrite) {
-      console.log(colors.red("Cancelled"));
-      process.exit(1);
+      return Result.err(new UserCancelledError("Cancelled"));
+    }
+    const removeDirectory = await shell`rm -rf ${dir}`.nothrow();
+    if (removeDirectory.exitCode !== 0) {
+      return Result.err(new ShellCommandError(`rm -rf ${dir}`, removeDirectory.stderr.toString().trim()));
     }
-    await shell`rm -rf ${dir}`;
-  } catch {}
+  }
   const spin = spinner("Creating project structure...");
   spin.start();
-  await shell`mkdir -p ${dir}`;
-  try {
-    let templateSource = template;
-    if (await isLocalTemplate(template)) {
-      templateSource = getBundledTemplatePath(template);
-    } else {
-      templateSource = resolveTemplateSource(template);
+  const mkdirResult = await shell`mkdir -p ${dir}`.nothrow();
+  if (mkdirResult.exitCode !== 0) {
+    spin.fail("Failed to create project directory");
+    return Result.err(new ShellCommandError(`mkdir -p ${dir}`, mkdirResult.stderr.toString().trim()));
+  }
+  let templateSource = template;
+  if (await isLocalTemplate(template)) {
+    templateSource = getBundledTemplatePath(template);
+  } else {
+    templateSource = resolveTemplateSource(template);
+  }
+  const templateResult = await tryAsync(() => processTemplate({
+    source: templateSource,
+    dir,
+    offline,
+    variables: {
+      name,
+      version: "0.1.0",
+      description: "A CLI built with Bunli",
+      author: "",
+      license: "MIT",
+      year: new Date().getFullYear().toString()
     }
-    const { manifest } = await processTemplate({
-      source: templateSource,
-      dir,
-      offline,
-      variables: {
-        name,
-        version: "0.1.0",
-        description: `A CLI built with Bunli`,
-        author: "",
-        license: "MIT",
-        year: new Date().getFullYear().toString()
-      }
-    });
-    spin.succeed("Project structure created");
-    if (git) {
-      const gitSpin = spinner("Initializing git repository...");
-      gitSpin.start();
-      try {
-        await shell`cd ${dir} && git init`.quiet();
-        await shell`cd ${dir} && git add .`.quiet();
-        await shell`cd ${dir} && git commit -m "feat: initialize ${name} CLI project with Bunli
+  }), (cause) => new TemplateProcessingError(cause));
+  if (Result.isError(templateResult)) {
+    spin.fail("Failed to create project");
+    console.error(colors.red(templateResult.error.message));
+    const cleanup = await shell`rm -rf ${dir}`.nothrow();
+    if (cleanup.exitCode !== 0) {
+      console.error(colors.yellow(`Warning: cleanup failed: ${cleanup.stderr.toString().trim()}`));
+    }
+    return templateResult;
+  }
+  spin.succeed("Project structure created");
+  if (git) {
+    const gitSpin = spinner("Initializing git repository...");
+    gitSpin.start();
+    const gitInit = await shell`cd ${dir} && git init`.nothrow();
+    const gitAdd = await shell`cd ${dir} && git add .`.nothrow();
+    const gitCommit = await shell`cd ${dir} && git commit -m "feat: initialize ${name} CLI project with Bunli
 
 - Generated using create-bunli template
 - Includes basic CLI structure with commands directory
 - Configured with Bunli build system and TypeScript
-- Ready for development with bun run dev"`;
-        gitSpin.succeed("Git repository initialized");
-      } catch (error) {
-        gitSpin.fail("Failed to initialize git repository");
-        console.error(colors.dim(`  ${error}`));
+- Ready for development with bun run dev"`.nothrow();
+    if (gitInit.exitCode === 0 && gitAdd.exitCode === 0 && gitCommit.exitCode === 0) {
+      gitSpin.succeed("Git repository initialized");
+    } else {
+      gitSpin.fail("Failed to initialize git repository");
+      const output = [gitInit.stderr, gitAdd.stderr, gitCommit.stderr].map((value) => value.toString().trim()).filter(Boolean).join(`
+`);
+      if (output) {
+        console.error(colors.dim(`  ${output}`));
       }
     }
-    if (install) {
-      const installSpin = spinner(`Installing dependencies...`);
-      installSpin.start();
-      try {
-        await shell`cd ${dir} && bun install`;
-        installSpin.succeed("Dependencies installed");
-      } catch (error) {
-        installSpin.fail("Failed to install dependencies");
-        console.error(colors.dim(`  You can install them manually by running: bun install`));
+  }
+  if (install) {
+    const installSpin = spinner("Installing dependencies...");
+    installSpin.start();
+    const installResult = await shell`cd ${dir} && bun install`.nothrow();
+    if (installResult.exitCode === 0) {
+      installSpin.succeed("Dependencies installed");
+    } else {
+      installSpin.fail("Failed to install dependencies");
+      console.error(colors.dim("  You can install them manually by running: bun install"));
+      const errorOutput = installResult.stderr.toString().trim();
+      if (errorOutput) {
+        console.error(colors.dim(`  ${errorOutput}`));
       }
     }
-  } catch (error) {
-    spin.fail("Failed to create project");
-    console.error(colors.red(`Error: ${error}`));
-    try {
-      await shell`rm -rf ${dir}`.quiet();
-    } catch {}
-    process.exit(1);
   }
+  return Result.ok(undefined);
 }
 
 // src/index.ts