project-runner 0.1.0 → 0.1.2

package/dist/index.js

@@ -0,0 +1,648 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { resolve } from "path";
+
+// src/utils/log.ts
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+var isVerbose = false;
+function setVerbose(verbose) {
+  isVerbose = verbose;
+}
+function log(message) {
+  if (isVerbose) {
+    console.log(`${colors.cyan}[pr]${colors.reset} ${message}`);
+  }
+}
+function info(message) {
+  console.log(`${colors.cyan}[pr]${colors.reset} ${message}`);
+}
+function success(message) {
+  console.log(`${colors.green}\u2713${colors.reset} ${message}`);
+}
+function warn(message) {
+  console.log(`${colors.yellow}\u26A0${colors.reset} ${message}`);
+}
+function error(message) {
+  console.error(`${colors.red}\u2717${colors.reset} ${message}`);
+}
+function execLog(command) {
+  console.log(`${colors.dim}>${colors.reset} ${colors.bold}${command}${colors.reset}`);
+}
+function newline() {
+  console.log();
+}
+
+// src/runner/executor.ts
+import { spawn } from "child_process";
+var currentProcess = null;
+async function execute(cmd, options = {}) {
+  const { cwd = process.cwd(), env, silent = false } = options;
+  if (!silent) {
+    execLog(cmd.join(" "));
+  }
+  return new Promise((resolve2, reject) => {
+    const isWindows = process.platform === "win32";
+    const command = cmd[0] || "";
+    const args = cmd.slice(1);
+    currentProcess = spawn(command, args, {
+      cwd,
+      env: { ...process.env, ...env },
+      stdio: "inherit",
+      shell: isWindows
+    });
+    const proc = currentProcess;
+    proc.on("close", (code) => {
+      currentProcess = null;
+      resolve2(code ?? 0);
+    });
+    proc.on("error", (err) => {
+      currentProcess = null;
+      reject(err);
+    });
+  });
+}
+function setupSignalHandlers() {
+  process.on("SIGINT", () => {
+    if (currentProcess) {
+      currentProcess.kill();
+    }
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    if (currentProcess) {
+      currentProcess.kill();
+    }
+    process.exit(0);
+  });
+}
+
+// src/analyzer/index.ts
+import { readFile as readFile3, stat as stat4 } from "fs/promises";
+import { join as join4 } from "path";
+
+// src/analyzer/package-manager.ts
+import { readFile, stat } from "fs/promises";
+import { join } from "path";
+var LOCKFILE_MAP = {
+  "bun.lockb": "bun",
+  "bun.lock": "bun",
+  "pnpm-lock.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm"
+};
+async function detectPackageManager(projectDir) {
+  const packageJsonPath = join(projectDir, "package.json");
+  const packageJson = await readPackageJson(packageJsonPath);
+  if (!packageJson) {
+    return { name: "npm", source: "default" };
+  }
+  if (packageJson.packageManager) {
+    const match = packageJson.packageManager.match(/^(npm|yarn|pnpm|bun)@(.+)$/);
+    if (match) {
+      return {
+        name: match[1],
+        version: match[2],
+        source: "packageManager"
+      };
+    }
+  }
+  if (packageJson.volta) {
+    for (const pm of ["pnpm", "yarn", "npm"]) {
+      if (packageJson.volta[pm]) {
+        return {
+          name: pm,
+          version: packageJson.volta[pm],
+          source: "volta"
+        };
+      }
+    }
+  }
+  for (const [lockfile, pm] of Object.entries(LOCKFILE_MAP)) {
+    const exists = await fileExists(join(projectDir, lockfile));
+    if (exists) {
+      return { name: pm, source: "lockfile" };
+    }
+  }
+  return { name: "npm", source: "default" };
+}
+function getRunCommand(pm, script) {
+  switch (pm) {
+    case "bun":
+      return ["bun", "run", script];
+    case "pnpm":
+      return ["pnpm", script];
+    case "yarn":
+      return ["yarn", script];
+    case "npm":
+    default:
+      return ["npm", "run", script];
+  }
+}
+function getInstallCommand(pm) {
+  switch (pm) {
+    case "bun":
+      return ["bun", "install"];
+    case "pnpm":
+      return ["pnpm", "install"];
+    case "yarn":
+      return ["yarn", "install"];
+    case "npm":
+    default:
+      return ["npm", "install"];
+  }
+}
+async function fileExists(path) {
+  try {
+    const stats = await stat(path);
+    return stats.isFile();
+  } catch {
+    return false;
+  }
+}
+async function readPackageJson(path) {
+  try {
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+  }
+  return null;
+}
+
+// src/analyzer/scripts.ts
+import { readFile as readFile2, stat as stat2 } from "fs/promises";
+import { join as join2 } from "path";
+var DEV_PATTERNS = ["dev", "serve", "start:dev", "develop", "watch"];
+var TEST_PATTERNS = ["test", "test:unit", "test:all", "spec"];
+var BUILD_PATTERNS = ["build", "compile", "bundle", "dist"];
+var START_PATTERNS = ["start", "serve", "preview", "production"];
+async function fileExists2(path) {
+  try {
+    const stats = await stat2(path);
+    return stats.isFile();
+  } catch {
+    return false;
+  }
+}
+async function analyzeScripts(projectDir) {
+  const packageJsonPath = join2(projectDir, "package.json");
+  try {
+    if (!await fileExists2(packageJsonPath)) {
+      return null;
+    }
+    const content = await readFile2(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(content);
+    const scripts = packageJson.scripts || {};
+    const detected = {
+      dev: findMatchingScript(scripts, DEV_PATTERNS),
+      test: findMatchingScript(scripts, TEST_PATTERNS),
+      build: findMatchingScript(scripts, BUILD_PATTERNS),
+      start: findMatchingScript(scripts, START_PATTERNS)
+    };
+    return { scripts, detected };
+  } catch {
+    return null;
+  }
+}
+function findMatchingScript(scripts, patterns) {
+  const scriptNames = Object.keys(scripts);
+  for (const pattern of patterns) {
+    if (scripts[pattern]) {
+      return pattern;
+    }
+  }
+  for (const pattern of patterns) {
+    const fuzzyMatch = scriptNames.find((name) => {
+      if (!name.toLowerCase().includes(pattern.toLowerCase())) {
+        return false;
+      }
+      const scriptContent = scripts[name].toLowerCase();
+      if (scriptContent.includes("npm i") || scriptContent.includes("npm install") || scriptContent.includes("yarn install") || scriptContent.includes("pnpm install") || scriptContent.includes("bun install")) {
+        return false;
+      }
+      return true;
+    });
+    if (fuzzyMatch) {
+      return fuzzyMatch;
+    }
+  }
+  return void 0;
+}
+
+// src/analyzer/dependencies.ts
+import { stat as stat3 } from "fs/promises";
+import { join as join3 } from "path";
+var LOCKFILES = [
+  "bun.lockb",
+  "bun.lock",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "package-lock.json"
+];
+async function checkDependencyStatus(projectDir) {
+  const nodeModulesPath = join3(projectDir, "node_modules");
+  const nodeModulesExists = await directoryExists(nodeModulesPath);
+  if (!nodeModulesExists) {
+    return {
+      hasNodeModules: false,
+      needsInstall: true,
+      reason: "node_modules \u4E0D\u5B58\u5728"
+    };
+  }
+  const lockfilePath = await findLockfile(projectDir);
+  if (lockfilePath) {
+    const lockfileMtime = await getModifiedTime(lockfilePath);
+    const nodeModulesMtime2 = await getModifiedTime(nodeModulesPath);
+    if (lockfileMtime && nodeModulesMtime2 && lockfileMtime > nodeModulesMtime2) {
+      return {
+        hasNodeModules: true,
+        needsInstall: true,
+        reason: "lockfile \u5DF2\u66F4\u65B0"
+      };
+    }
+  }
+  const packageJsonPath = join3(projectDir, "package.json");
+  const packageJsonMtime = await getModifiedTime(packageJsonPath);
+  const nodeModulesMtime = await getModifiedTime(nodeModulesPath);
+  if (packageJsonMtime && nodeModulesMtime && packageJsonMtime > nodeModulesMtime) {
+    return {
+      hasNodeModules: true,
+      needsInstall: true,
+      reason: "package.json \u5DF2\u66F4\u65B0"
+    };
+  }
+  return {
+    hasNodeModules: true,
+    needsInstall: false
+  };
+}
+async function findLockfile(projectDir) {
+  for (const lockfile of LOCKFILES) {
+    const lockfilePath = join3(projectDir, lockfile);
+    if (await fileExists3(lockfilePath)) {
+      return lockfilePath;
+    }
+  }
+  return null;
+}
+async function getModifiedTime(path) {
+  try {
+    const stats = await stat3(path);
+    return stats.mtimeMs;
+  } catch {
+    return null;
+  }
+}
+async function directoryExists(path) {
+  try {
+    const stats = await stat3(path);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function fileExists3(path) {
+  try {
+    const stats = await stat3(path);
+    return stats.isFile();
+  } catch {
+    return false;
+  }
+}
+
+// src/analyzer/index.ts
+async function fileExists4(path) {
+  try {
+    const stats = await stat4(path);
+    return stats.isFile();
+  } catch {
+    return false;
+  }
+}
+async function analyzeProject(projectDir) {
+  const packageJsonPath = join4(projectDir, "package.json");
+  const hasPackageJson = await fileExists4(packageJsonPath);
+  if (!hasPackageJson) {
+    return {
+      type: "unknown",
+      packageManager: { name: "npm", source: "default" },
+      scripts: null,
+      dependencies: { hasNodeModules: false, needsInstall: false }
+    };
+  }
+  let packageJson = {};
+  try {
+    const content = await readFile3(packageJsonPath, "utf-8");
+    packageJson = JSON.parse(content);
+  } catch {
+  }
+  const [packageManager, scripts, dependencies] = await Promise.all([
+    detectPackageManager(projectDir),
+    analyzeScripts(projectDir),
+    checkDependencyStatus(projectDir)
+  ]);
+  return {
+    type: "nodejs",
+    packageManager,
+    scripts,
+    dependencies,
+    name: packageJson.name,
+    version: packageJson.version,
+    description: packageJson.description
+  };
+}
+
+// src/cli/run.ts
+async function runCommand(projectDir, options = {}) {
+  const { noInstall = false, forceInstall = false, scriptType = "dev" } = options;
+  log("\u6B63\u5728\u5206\u6790\u9879\u76EE...");
+  const project = await analyzeProject(projectDir);
+  if (project.type === "unknown") {
+    error("\u672A\u68C0\u6D4B\u5230\u9879\u76EE\u7C7B\u578B\u3002\u8BF7\u786E\u4FDD\u5F53\u524D\u76EE\u5F55\u5305\u542B package.json");
+    process.exit(1);
+  }
+  log(`\u9879\u76EE\u7C7B\u578B: ${project.type}`);
+  log(`\u5305\u7BA1\u7406\u5668: ${project.packageManager.name} (from ${project.packageManager.source})`);
+  if (!project.scripts) {
+    error("\u65E0\u6CD5\u8BFB\u53D6 package.json \u7684 scripts");
+    process.exit(1);
+  }
+  const scriptName = findScript(project, scriptType);
+  if (!scriptName) {
+    error(`\u672A\u627E\u5230 ${scriptType} \u76F8\u5173\u7684\u811A\u672C`);
+    showAvailableScripts(project);
+    process.exit(1);
+  }
+  log(`\u5C06\u6267\u884C\u811A\u672C: ${scriptName}`);
+  const shouldInstall = !noInstall && (forceInstall || project.dependencies.needsInstall);
+  if (shouldInstall) {
+    if (forceInstall) {
+      log("\u5F3A\u5236\u5B89\u88C5\u4F9D\u8D56...");
+    } else {
+      log(`\u4F9D\u8D56\u72B6\u6001: ${project.dependencies.reason || "\u9700\u8981\u5B89\u88C5"}`);
+    }
+    newline();
+    const installCmd = getInstallCommand(project.packageManager.name);
+    const installExitCode = await execute(installCmd, { cwd: projectDir });
+    if (installExitCode !== 0) {
+      error("\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25");
+      process.exit(installExitCode);
+    }
+    success("\u4F9D\u8D56\u5B89\u88C5\u5B8C\u6210");
+    newline();
+  } else if (!noInstall) {
+    log("\u4F9D\u8D56\u72B6\u6001: \u5DF2\u662F\u6700\u65B0");
+  }
+  const runCmd = getRunCommand(project.packageManager.name, scriptName);
+  const exitCode = await execute(runCmd, { cwd: projectDir });
+  if (exitCode !== 0) {
+    process.exit(exitCode);
+  }
+}
+function findScript(project, scriptType) {
+  const scripts = project.scripts;
+  if (!scripts)
+    return void 0;
+  const detected = scripts.detected[scriptType];
+  if (detected) {
+    return detected;
+  }
+  if (scripts.scripts[scriptType]) {
+    return scriptType;
+  }
+  return void 0;
+}
+function showAvailableScripts(project) {
+  if (!project.scripts)
+    return;
+  const scriptNames = Object.keys(project.scripts.scripts);
+  if (scriptNames.length === 0) {
+    warn("package.json \u4E2D\u6CA1\u6709\u5B9A\u4E49\u4EFB\u4F55 scripts");
+    return;
+  }
+  info("\u53EF\u7528\u7684\u811A\u672C:");
+  for (const name of scriptNames) {
+    console.log(`  - ${name}`);
+  }
+  console.log();
+  info("\u4F7F\u7528 qy <script> \u8FD0\u884C\u4EFB\u610F\u811A\u672C");
+}
+
+// src/cli/info.ts
+async function infoCommand(projectDir) {
+  const project = await analyzeProject(projectDir);
+  if (project.type === "unknown") {
+    console.log(`${colors.red}\u2717${colors.reset} \u672A\u68C0\u6D4B\u5230\u9879\u76EE\u7C7B\u578B`);
+    console.log("  \u8BF7\u786E\u4FDD\u5F53\u524D\u76EE\u5F55\u5305\u542B package.json \u6216\u5176\u4ED6\u9879\u76EE\u914D\u7F6E\u6587\u4EF6");
+    return;
+  }
+  console.log();
+  console.log(`${colors.cyan}${colors.bold}pr - \u9879\u76EE\u5206\u6790\u7ED3\u679C${colors.reset}`);
+  console.log("\u2500".repeat(40));
+  if (project.name) {
+    console.log(`${colors.bold}\u9879\u76EE\u540D\u79F0:${colors.reset} ${project.name}`);
+  }
+  if (project.version) {
+    console.log(`${colors.bold}\u7248\u672C:${colors.reset}     ${project.version}`);
+  }
+  if (project.description) {
+    console.log(`${colors.bold}\u63CF\u8FF0:${colors.reset}     ${project.description}`);
+  }
+  console.log(`${colors.bold}\u9879\u76EE\u7C7B\u578B:${colors.reset} ${project.type}`);
+  const pm = project.packageManager;
+  let pmInfo = pm.name;
+  if (pm.version) {
+    pmInfo += `@${pm.version}`;
+  }
+  pmInfo += ` ${colors.dim}(${pm.source})${colors.reset}`;
+  console.log(`${colors.bold}\u5305\u7BA1\u7406\u5668:${colors.reset} ${pmInfo}`);
+  const deps = project.dependencies;
+  const depsStatus = deps.needsInstall ? `${colors.yellow}\u9700\u8981\u5B89\u88C5${colors.reset} (${deps.reason})` : `${colors.green}\u5DF2\u5C31\u7EEA${colors.reset}`;
+  console.log(`${colors.bold}\u4F9D\u8D56\u72B6\u6001:${colors.reset} ${depsStatus}`);
+  console.log();
+  if (project.scripts) {
+    const { scripts, detected } = project.scripts;
+    console.log(`${colors.bold}\u8BC6\u522B\u7684\u547D\u4EE4:${colors.reset}`);
+    if (detected.dev) {
+      console.log(`  ${colors.green}pr run${colors.reset}   \u2192 ${pm.name} ${detected.dev}`);
+    }
+    if (detected.test) {
+      console.log(`  ${colors.green}pr test${colors.reset}  \u2192 ${pm.name} ${detected.test}`);
+    }
+    if (detected.build) {
+      console.log(`  ${colors.green}pr build${colors.reset} \u2192 ${pm.name} ${detected.build}`);
+    }
+    if (detected.start) {
+      console.log(`  ${colors.green}pr start${colors.reset} \u2192 ${pm.name} ${detected.start}`);
+    }
+    console.log();
+    const allScripts = Object.keys(scripts);
+    if (allScripts.length > 0) {
+      console.log(`${colors.bold}\u6240\u6709\u811A\u672C:${colors.reset}`);
+      for (const name of allScripts) {
+        const cmd = scripts[name];
+        const displayCmd = cmd.length > 40 ? cmd.slice(0, 40) + "..." : cmd;
+        console.log(`  ${colors.cyan}${name}${colors.reset} ${colors.dim}\u2192 ${displayCmd}${colors.reset}`);
+      }
+    }
+  }
+  console.log();
+}
+
+// src/cli/script.ts
+async function scriptCommand(projectDir, scriptName) {
+  const project = await analyzeProject(projectDir);
+  if (project.type === "unknown") {
+    error("\u672A\u68C0\u6D4B\u5230\u9879\u76EE\u7C7B\u578B\u3002\u8BF7\u786E\u4FDD\u5F53\u524D\u76EE\u5F55\u5305\u542B package.json");
+    process.exit(1);
+  }
+  if (!project.scripts) {
+    error("\u65E0\u6CD5\u8BFB\u53D6 package.json \u7684 scripts");
+    process.exit(1);
+  }
+  const scripts = project.scripts.scripts;
+  if (!(scriptName in scripts)) {
+    error(`\u811A\u672C "${scriptName}" \u4E0D\u5B58\u5728`);
+    console.log();
+    showAvailableScripts2(scripts);
+    process.exit(1);
+  }
+  log(`\u5305\u7BA1\u7406\u5668: ${project.packageManager.name}`);
+  log(`\u6267\u884C\u811A\u672C: ${scriptName}`);
+  const runCmd = getRunCommand(project.packageManager.name, scriptName);
+  const exitCode = await execute(runCmd, { cwd: projectDir });
+  if (exitCode !== 0) {
+    process.exit(exitCode);
+  }
+}
+function showAvailableScripts2(scripts) {
+  const scriptNames = Object.keys(scripts);
+  if (scriptNames.length === 0) {
+    info("package.json \u4E2D\u6CA1\u6709\u5B9A\u4E49\u4EFB\u4F55\u811A\u672C");
+    return;
+  }
+  info("\u53EF\u7528\u7684\u811A\u672C:");
+  for (const name of scriptNames) {
+    console.log(`  - ${name}`);
+  }
+}
+
+// src/index.ts
+var VERSION = "0.1.2";
+function parseArgs(args) {
+  const options = {
+    verbose: false,
+    dir: process.cwd(),
+    noInstall: false,
+    install: false
+  };
+  let command = "";
+  const remainingArgs = [];
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === "-v" || arg === "--verbose") {
+      options.verbose = true;
+    } else if (arg === "-d" || arg === "--dir") {
+      options.dir = resolve(args[++i] || ".");
+    } else if (arg === "--no-install") {
+      options.noInstall = true;
+    } else if (arg === "-i" || arg === "--install") {
+      options.install = true;
+    } else if (arg === "-h" || arg === "--help") {
+      command = "help";
+    } else if (arg === "-V" || arg === "--version") {
+      command = "version";
+    } else if (!arg.startsWith("-")) {
+      if (!command) {
+        command = arg;
+      } else {
+        remainingArgs.push(arg);
+      }
+    }
+    i++;
+  }
+  return { command, options, args: remainingArgs };
+}
+function showHelp() {
+  console.log(`
+${"\x1B[36m"}pr${"\x1B[0m"} v${VERSION} - \u96F6\u914D\u7F6E\u667A\u80FD\u9879\u76EE\u8FD0\u884C\u5668 (project-runner)
+
+${"\x1B[1m"}\u7528\u6CD5:${"\x1B[0m"} pr <command> [options]
+
+${"\x1B[1m"}\u547D\u4EE4:${"\x1B[0m"}
+  run              \u5B8C\u6574\u6D41\u7A0B\uFF1A\u68C0\u6D4B \u2192 install \u2192 \u542F\u52A8\u5F00\u53D1\u670D\u52A1\u5668
+  test             \u8FD0\u884C\u6D4B\u8BD5
+  build            \u6784\u5EFA\u9879\u76EE
+  start            \u751F\u4EA7\u6A21\u5F0F\u542F\u52A8
+  info             \u663E\u793A\u9879\u76EE\u5206\u6790\u7ED3\u679C
+  <script>         \u8FD0\u884C package.json \u4E2D\u7684\u4EFB\u610F\u811A\u672C
+
+${"\x1B[1m"}\u9009\u9879:${"\x1B[0m"}
+  -v, --verbose    \u663E\u793A\u8BE6\u7EC6\u68C0\u6D4B\u8FC7\u7A0B
+  -d, --dir <path> \u6307\u5B9A\u9879\u76EE\u76EE\u5F55 (\u9ED8\u8BA4: \u5F53\u524D\u76EE\u5F55)
+  -i, --install    \u5F3A\u5236\u6267\u884C\u4F9D\u8D56\u5B89\u88C5
+  --no-install     \u8DF3\u8FC7\u4F9D\u8D56\u5B89\u88C5\u6B65\u9AA4
+  -h, --help       \u663E\u793A\u5E2E\u52A9\u4FE1\u606F
+  -V, --version    \u663E\u793A\u7248\u672C\u53F7
+
+${"\x1B[1m"}\u793A\u4F8B:${"\x1B[0m"}
+  pr run           \u4E00\u952E\u542F\u52A8\u9879\u76EE
+  pr run -i        \u5F3A\u5236\u5B89\u88C5\u4F9D\u8D56\u540E\u542F\u52A8
+  pr run -v        \u663E\u793A\u8BE6\u7EC6\u68C0\u6D4B\u8FC7\u7A0B
+  pr test          \u8FD0\u884C\u6D4B\u8BD5
+  pr lint          \u8FD0\u884C lint \u811A\u672C
+  pr info          \u67E5\u770B\u9879\u76EE\u4FE1\u606F
+`);
+}
+function showVersion() {
+  console.log(`pr v${VERSION}`);
+}
+async function main() {
+  setupSignalHandlers();
+  const { command, options, args } = parseArgs(process.argv.slice(2));
+  setVerbose(options.verbose);
+  switch (command) {
+    case "":
+    case "help":
+      showHelp();
+      break;
+    case "version":
+      showVersion();
+      break;
+    case "run":
+      await runCommand(options.dir, { noInstall: options.noInstall, forceInstall: options.install, scriptType: "dev" });
+      break;
+    case "test":
+      await runCommand(options.dir, { noInstall: true, scriptType: "test" });
+      break;
+    case "build":
+      await runCommand(options.dir, { noInstall: true, scriptType: "build" });
+      break;
+    case "start":
+      await runCommand(options.dir, { noInstall: true, scriptType: "start" });
+      break;
+    case "info":
+      await infoCommand(options.dir);
+      break;
+    default:
+      await scriptCommand(options.dir, command);
+      break;
+  }
+}
+main().catch((err) => {
+  error(err.message);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-runner",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "零配置智能项目运行器 - 一键运行任意 Node.js 项目",
   "author": "liangzhenqi",
   "license": "MIT",
@@ -20,23 +20,23 @@
     "build",
     "test"
   ],
-  "module": "src/index.ts",
   "type": "module",
   "bin": {
-    "pr": "src/index.ts"
+    "pr": "dist/index.js"
   },
   "files": [
-    "src",
+    "dist",
     "README.md"
   ],
   "scripts": {
     "dev": "bun run src/index.ts",
-    "build": "bun build src/index.ts --outdir dist --target node",
-    "link": "bun link",
-    "prepublishOnly": "echo 'Ready to publish'"
+    "build": "node build.mjs",
+    "prepublishOnly": "npm run build"
   },
   "devDependencies": {
-    "@types/bun": "latest"
+    "@types/bun": "latest",
+    "@types/node": "^20",
+    "esbuild": "^0.20.0"
   },
   "peerDependencies": {
     "typescript": "^5"