project-runner 0.1.2 → 0.2.0

package/README.md

@@ -104,6 +104,7 @@ pr info
 |------|------|
 | `-v, --verbose` | 显示详细检测过程 |
 | `-d, --dir <path>` | 指定项目目录（默认：当前目录）|
+| `-i, --install` | 强制执行依赖安装 |
 | `--no-install` | 跳过依赖安装步骤 |
 | `-h, --help` | 显示帮助信息 |
 | `-V, --version` | 显示版本号 |

package/dist/index.js

@@ -17,6 +17,13 @@ var colors = {
   white: "\x1B[37m",
   gray: "\x1B[90m"
 };
+var CliError = class extends Error {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+};
 var isVerbose = false;
 function setVerbose(verbose) {
   isVerbose = verbose;
@@ -74,6 +81,34 @@ async function execute(cmd, options = {}) {
     });
   });
 }
+async function executeCapture(cmd, options = {}) {
+  const { cwd = process.cwd(), env } = options;
+  return new Promise((resolve2, reject) => {
+    const isWindows = process.platform === "win32";
+    const command = cmd[0] || "";
+    const args = cmd.slice(1);
+    const proc = spawn(command, args, {
+      cwd,
+      env: { ...process.env, ...env },
+      shell: isWindows,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      resolve2({ stdout, stderr, exitCode: code ?? 0 });
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
 function setupSignalHandlers() {
   process.on("SIGINT", () => {
     if (currentProcess) {
@@ -90,12 +125,32 @@ function setupSignalHandlers() {
 }
 
 // src/analyzer/index.ts
-import { readFile as readFile3, stat as stat4 } from "fs/promises";
-import { join as join4 } from "path";
+import { readFile } from "fs/promises";
+import { join as join3 } from "path";
 
 // src/analyzer/package-manager.ts
-import { readFile, stat } from "fs/promises";
 import { join } from "path";
+
+// src/utils/fs.ts
+import { stat } from "fs/promises";
+async function fileExists(path) {
+  try {
+    const stats = await stat(path);
+    return stats.isFile();
+  } catch {
+    return false;
+  }
+}
+async function directoryExists(path) {
+  try {
+    const stats = await stat(path);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/analyzer/package-manager.ts
 var LOCKFILE_MAP = {
   "bun.lockb": "bun",
   "bun.lock": "bun",
@@ -103,9 +158,7 @@ var LOCKFILE_MAP = {
   "yarn.lock": "yarn",
   "package-lock.json": "npm"
 };
-async function detectPackageManager(projectDir) {
-  const packageJsonPath = join(projectDir, "package.json");
-  const packageJson = await readPackageJson(packageJsonPath);
+async function detectPackageManager(projectDir, packageJson) {
   if (!packageJson) {
     return { name: "npm", source: "default" };
   }
@@ -164,46 +217,17 @@ function getInstallCommand(pm) {
       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;
+var START_PATTERNS = ["start", "preview", "production"];
+function analyzeScripts(packageJson) {
+  if (!packageJson) {
+    return null;
   }
-}
-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),
@@ -242,8 +266,8 @@ function findMatchingScript(scripts, patterns) {
 }
 
 // src/analyzer/dependencies.ts
-import { stat as stat3 } from "fs/promises";
-import { join as join3 } from "path";
+import { stat as stat2 } from "fs/promises";
+import { join as join2 } from "path";
 var LOCKFILES = [
   "bun.lockb",
   "bun.lock",
@@ -252,7 +276,7 @@ var LOCKFILES = [
   "package-lock.json"
 ];
 async function checkDependencyStatus(projectDir) {
-  const nodeModulesPath = join3(projectDir, "node_modules");
+  const nodeModulesPath = join2(projectDir, "node_modules");
   const nodeModulesExists = await directoryExists(nodeModulesPath);
   if (!nodeModulesExists) {
     return {
@@ -261,11 +285,11 @@ async function checkDependencyStatus(projectDir) {
       reason: "node_modules \u4E0D\u5B58\u5728"
     };
   }
+  const nodeModulesMtime = await getModifiedTime(nodeModulesPath);
   const lockfilePath = await findLockfile(projectDir);
   if (lockfilePath) {
     const lockfileMtime = await getModifiedTime(lockfilePath);
-    const nodeModulesMtime2 = await getModifiedTime(nodeModulesPath);
-    if (lockfileMtime && nodeModulesMtime2 && lockfileMtime > nodeModulesMtime2) {
+    if (lockfileMtime && nodeModulesMtime && lockfileMtime > nodeModulesMtime) {
       return {
         hasNodeModules: true,
         needsInstall: true,
@@ -273,9 +297,8 @@ async function checkDependencyStatus(projectDir) {
       };
     }
   }
-  const packageJsonPath = join3(projectDir, "package.json");
+  const packageJsonPath = join2(projectDir, "package.json");
   const packageJsonMtime = await getModifiedTime(packageJsonPath);
-  const nodeModulesMtime = await getModifiedTime(nodeModulesPath);
   if (packageJsonMtime && nodeModulesMtime && packageJsonMtime > nodeModulesMtime) {
     return {
       hasNodeModules: true,
@@ -290,8 +313,8 @@ async function checkDependencyStatus(projectDir) {
 }
 async function findLockfile(projectDir) {
   for (const lockfile of LOCKFILES) {
-    const lockfilePath = join3(projectDir, lockfile);
-    if (await fileExists3(lockfilePath)) {
+    const lockfilePath = join2(projectDir, lockfile);
+    if (await fileExists(lockfilePath)) {
       return lockfilePath;
     }
   }
@@ -299,41 +322,17 @@ async function findLockfile(projectDir) {
 }
 async function getModifiedTime(path) {
   try {
-    const stats = await stat3(path);
+    const stats = await stat2(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);
+  const packageJsonPath = join3(projectDir, "package.json");
+  const hasPackageJson = await fileExists(packageJsonPath);
   if (!hasPackageJson) {
     return {
       type: "unknown",
@@ -344,15 +343,15 @@ async function analyzeProject(projectDir) {
   }
   let packageJson = {};
   try {
-    const content = await readFile3(packageJsonPath, "utf-8");
+    const content = await readFile(packageJsonPath, "utf-8");
     packageJson = JSON.parse(content);
   } catch {
   }
-  const [packageManager, scripts, dependencies] = await Promise.all([
-    detectPackageManager(projectDir),
-    analyzeScripts(projectDir),
+  const [packageManager, dependencies] = await Promise.all([
+    detectPackageManager(projectDir, packageJson),
     checkDependencyStatus(projectDir)
   ]);
+  const scripts = analyzeScripts(packageJson);
   return {
     type: "nodejs",
     packageManager,
@@ -364,28 +363,115 @@ async function analyzeProject(projectDir) {
   };
 }
 
+// src/utils/pm-availability.ts
+import { createInterface } from "node:readline/promises";
+var availabilityCache = /* @__PURE__ */ new Map();
+async function isPmAvailable(pm) {
+  if (availabilityCache.has(pm)) {
+    return availabilityCache.get(pm);
+  }
+  try {
+    const result = await executeCapture([pm, "--version"]);
+    const available = result.exitCode === 0 && result.stdout.trim().length > 0;
+    availabilityCache.set(pm, available);
+    return available;
+  } catch {
+    availabilityCache.set(pm, false);
+    return false;
+  }
+}
+async function ensurePmAvailable(pm) {
+  if (pm === "npm") {
+    return pm;
+  }
+  const available = await isPmAvailable(pm);
+  if (available) {
+    return pm;
+  }
+  warn(`\u5305\u7BA1\u7406\u5668 ${pm} \u672A\u5B89\u88C5`);
+  if (!process.stdin.isTTY) {
+    warn("\u975E\u4EA4\u4E92\u73AF\u5883\uFF0C\u81EA\u52A8\u56DE\u9000\u5230 npm");
+    return "npm";
+  }
+  return await promptPmResolution(pm);
+}
+async function promptPmResolution(pm) {
+  console.log();
+  console.log(`  \u68C0\u6D4B\u5230\u9879\u76EE\u4F7F\u7528 ${colors.cyan}${pm}${colors.reset}\uFF0C\u4F46\u7CFB\u7EDF\u672A\u5B89\u88C5\u3002`);
+  console.log();
+  console.log(`  ${colors.bold}\u8BF7\u9009\u62E9\u64CD\u4F5C:${colors.reset}`);
+  console.log(`    ${colors.cyan}1${colors.reset}) \u81EA\u52A8\u5B89\u88C5 ${pm} ${colors.dim}(npm install -g ${pm})${colors.reset}`);
+  console.log(`    ${colors.cyan}2${colors.reset}) \u4F7F\u7528 npm \u4EE3\u66FF`);
+  console.log(`    ${colors.cyan}3${colors.reset}) \u9000\u51FA\uFF0C\u624B\u52A8\u5904\u7406`);
+  console.log();
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(`  \u8BF7\u8F93\u5165\u9009\u9879 ${colors.dim}[1/2/3]${colors.reset}: `);
+    const choice = answer.trim();
+    switch (choice) {
+      case "1":
+        return await autoInstallPm(pm);
+      case "2":
+        warn(`\u4F7F\u7528 npm \u4EE3\u66FF ${pm}`);
+        return "npm";
+      case "3":
+      default:
+        throw new CliError(`\u8BF7\u5148\u5B89\u88C5 ${pm}: npm install -g ${pm}`);
+    }
+  } finally {
+    rl.close();
+  }
+}
+async function autoInstallPm(pm) {
+  info(`\u6B63\u5728\u5B89\u88C5 ${pm}...`);
+  console.log();
+  try {
+    const result = await executeCapture(["npm", "install", "-g", pm]);
+    if (result.exitCode !== 0) {
+      error(`\u5B89\u88C5 ${pm} \u5931\u8D25`);
+      if (result.stderr.trim()) {
+        console.error(result.stderr.trim());
+      }
+      throw new CliError(`\u65E0\u6CD5\u81EA\u52A8\u5B89\u88C5 ${pm}\uFF0C\u8BF7\u624B\u52A8\u8FD0\u884C: npm install -g ${pm}`);
+    }
+  } catch (err) {
+    if (err instanceof CliError)
+      throw err;
+    throw new CliError(`\u5B89\u88C5 ${pm} \u65F6\u51FA\u9519\uFF0C\u8BF7\u624B\u52A8\u8FD0\u884C: npm install -g ${pm}`);
+  }
+  availabilityCache.delete(pm);
+  const nowAvailable = await isPmAvailable(pm);
+  if (!nowAvailable) {
+    throw new CliError(`${pm} \u5DF2\u5B89\u88C5\u4F46\u65E0\u6CD5\u6267\u884C\u3002\u8BF7\u68C0\u67E5 PATH \u6216\u91CD\u65B0\u6253\u5F00\u7EC8\u7AEF\u540E\u91CD\u8BD5\u3002`);
+  }
+  success(`${pm} \u5B89\u88C5\u5B8C\u6210`);
+  console.log();
+  return pm;
+}
+
 // 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);
+    throw new CliError("\u672A\u68C0\u6D4B\u5230\u9879\u76EE\u7C7B\u578B\u3002\u8BF7\u786E\u4FDD\u5F53\u524D\u76EE\u5F55\u5305\u542B package.json");
   }
   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);
+    throw new CliError("\u65E0\u6CD5\u8BFB\u53D6 package.json \u7684 scripts");
   }
   const scriptName = findScript(project, scriptType);
   if (!scriptName) {
-    error(`\u672A\u627E\u5230 ${scriptType} \u76F8\u5173\u7684\u811A\u672C`);
     showAvailableScripts(project);
-    process.exit(1);
+    throw new CliError(`\u672A\u627E\u5230 ${scriptType} \u76F8\u5173\u7684\u811A\u672C`);
   }
   log(`\u5C06\u6267\u884C\u811A\u672C: ${scriptName}`);
+  const resolvedPm = await ensurePmAvailable(project.packageManager.name);
+  if (resolvedPm !== project.packageManager.name) {
+    log(`\u4F7F\u7528 ${resolvedPm} \u4EE3\u66FF ${project.packageManager.name}`);
+  }
   const shouldInstall = !noInstall && (forceInstall || project.dependencies.needsInstall);
   if (shouldInstall) {
     if (forceInstall) {
@@ -394,21 +480,20 @@ async function runCommand(projectDir, options = {}) {
       log(`\u4F9D\u8D56\u72B6\u6001: ${project.dependencies.reason || "\u9700\u8981\u5B89\u88C5"}`);
     }
     newline();
-    const installCmd = getInstallCommand(project.packageManager.name);
+    const installCmd = getInstallCommand(resolvedPm);
     const installExitCode = await execute(installCmd, { cwd: projectDir });
     if (installExitCode !== 0) {
-      error("\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25");
-      process.exit(installExitCode);
+      throw new CliError("\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25", 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 runCmd = getRunCommand(resolvedPm, scriptName);
   const exitCode = await execute(runCmd, { cwd: projectDir });
   if (exitCode !== 0) {
-    process.exit(exitCode);
+    throw new CliError("\u811A\u672C\u6267\u884C\u5931\u8D25", exitCode);
   }
 }
 function findScript(project, scriptType) {
@@ -437,7 +522,7 @@ function showAvailableScripts(project) {
     console.log(`  - ${name}`);
   }
   console.log();
-  info("\u4F7F\u7528 qy <script> \u8FD0\u884C\u4EFB\u610F\u811A\u672C");
+  info("\u4F7F\u7528 pr <script> \u8FD0\u884C\u4EFB\u610F\u811A\u672C");
 }
 
 // src/cli/info.ts
@@ -467,7 +552,9 @@ async function infoCommand(projectDir) {
     pmInfo += `@${pm.version}`;
   }
   pmInfo += ` ${colors.dim}(${pm.source})${colors.reset}`;
-  console.log(`${colors.bold}\u5305\u7BA1\u7406\u5668:${colors.reset} ${pmInfo}`);
+  const pmAvailable = await isPmAvailable(pm.name);
+  const pmStatus = pmAvailable ? `${colors.green}\u5DF2\u5B89\u88C5${colors.reset}` : `${colors.red}\u672A\u5B89\u88C5${colors.reset}`;
+  console.log(`${colors.bold}\u5305\u7BA1\u7406\u5668:${colors.reset} ${pmInfo} [${pmStatus}]`);
   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}`);
@@ -505,26 +592,23 @@ async function infoCommand(projectDir) {
 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);
+    throw new CliError("\u672A\u68C0\u6D4B\u5230\u9879\u76EE\u7C7B\u578B\u3002\u8BF7\u786E\u4FDD\u5F53\u524D\u76EE\u5F55\u5305\u542B package.json");
   }
   if (!project.scripts) {
-    error("\u65E0\u6CD5\u8BFB\u53D6 package.json \u7684 scripts");
-    process.exit(1);
+    throw new CliError("\u65E0\u6CD5\u8BFB\u53D6 package.json \u7684 scripts");
   }
   const scripts = project.scripts.scripts;
   if (!(scriptName in scripts)) {
-    error(`\u811A\u672C "${scriptName}" \u4E0D\u5B58\u5728`);
-    console.log();
     showAvailableScripts2(scripts);
-    process.exit(1);
+    throw new CliError(`\u811A\u672C "${scriptName}" \u4E0D\u5B58\u5728`);
   }
   log(`\u5305\u7BA1\u7406\u5668: ${project.packageManager.name}`);
   log(`\u6267\u884C\u811A\u672C: ${scriptName}`);
-  const runCmd = getRunCommand(project.packageManager.name, scriptName);
+  const resolvedPm = await ensurePmAvailable(project.packageManager.name);
+  const runCmd = getRunCommand(resolvedPm, scriptName);
   const exitCode = await execute(runCmd, { cwd: projectDir });
   if (exitCode !== 0) {
-    process.exit(exitCode);
+    throw new CliError("\u811A\u672C\u6267\u884C\u5931\u8D25", exitCode);
   }
 }
 function showAvailableScripts2(scripts) {
@@ -540,7 +624,7 @@ function showAvailableScripts2(scripts) {
 }
 
 // src/index.ts
-var VERSION = "0.1.2";
+var VERSION = true ? "0.2.0" : "0.0.0-dev";
 function parseArgs(args) {
   const options = {
     verbose: false,
@@ -571,6 +655,8 @@ function parseArgs(args) {
       } else {
         remainingArgs.push(arg);
       }
+    } else {
+      warn(`\u672A\u77E5\u9009\u9879: ${arg}`);
     }
     i++;
   }
@@ -643,6 +729,10 @@ async function main() {
   }
 }
 main().catch((err) => {
-  error(err.message);
+  if (err instanceof CliError) {
+    error(err.message);
+    process.exit(err.exitCode);
+  }
+  error(err.message || "\u672A\u77E5\u9519\u8BEF");
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-runner",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "零配置智能项目运行器 - 一键运行任意 Node.js 项目",
   "author": "liangzhenqi",
   "license": "MIT",