project-runner 0.2.0 → 0.3.0

package/README.md

@@ -106,9 +106,33 @@ pr info
 | `-d, --dir <path>` | 指定项目目录（默认：当前目录）|
 | `-i, --install` | 强制执行依赖安装 |
 | `--no-install` | 跳过依赖安装步骤 |
+| `-e, --entry <name>` | 指定 MPA 入口（也可用 `PR_ENTRY`） |
 | `-h, --help` | 显示帮助信息 |
 | `-V, --version` | 显示版本号 |
 
+## MPA 项目支持
+
+`pr run` 会自动检测是否存在 `dev:<entry>` 形式的多入口脚本。
+
+- 在交互终端中：自动弹出入口列表并让你选择。
+- 在 CI / 非交互环境中：按优先级选择入口
+  1. `--entry <name>`
+  2. `PR_ENTRY=<name>`
+  3. `.pr.local.json` 中的 `defaultEntry`
+  4. 若仍无法确定则报错并提示可选入口
+
+本地配置文件（推荐）：
+
+```json
+{
+  "entries": ["main", "formengine", "design", "approve"],
+  "defaultEntry": "main"
+}
+```
+
+- 文件名固定：`.pr.local.json`
+- 当该文件存在时，`pr` 会自动确保 `.gitignore` 包含 `.pr.local.json`
+
 ## 示例输出
 
 ### `pr info`

package/dist/index.js

@@ -124,9 +124,12 @@ function setupSignalHandlers() {
   });
 }
 
+// src/cli/run.ts
+import { createInterface as createInterface2 } from "node:readline/promises";
+
 // src/analyzer/index.ts
-import { readFile } from "fs/promises";
-import { join as join3 } from "path";
+import { readFile as readFile2 } from "fs/promises";
+import { join as join4 } from "path";
 
 // src/analyzer/package-manager.ts
 import { join } from "path";
@@ -223,7 +226,8 @@ 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", "preview", "production"];
-function analyzeScripts(packageJson) {
+var STANDARD_TYPES = ["dev", "test", "build", "start"];
+function analyzeScripts(packageJson, localConfig) {
   if (!packageJson) {
     return null;
   }
@@ -235,11 +239,81 @@ function analyzeScripts(packageJson) {
       build: findMatchingScript(scripts, BUILD_PATTERNS),
       start: findMatchingScript(scripts, START_PATTERNS)
     };
-    return { scripts, detected };
+    const mpa = analyzeMpa(packageJson, scripts, localConfig);
+    return { scripts, detected, mpa };
   } catch {
     return null;
   }
 }
+function analyzeMpa(packageJson, scripts, localConfig) {
+  const configuredEntriesFromLocal = normalizeEntryList(localConfig?.entries);
+  const configuredEntriesFromPackage = normalizeEntryList(packageJson?.pr?.entries);
+  const configuredEntries = configuredEntriesFromLocal.length > 0 ? configuredEntriesFromLocal : configuredEntriesFromPackage;
+  const scriptEntries = collectEntriesByPrefix(scripts, "dev");
+  let entries = configuredEntries.length > 0 ? configuredEntries : scriptEntries;
+  let source = "scripts";
+  if (configuredEntriesFromLocal.length > 0) {
+    source = "local-config";
+  } else if (configuredEntriesFromPackage.length > 0) {
+    source = "package-json";
+  }
+  const defaultEntry = normalizeEntryName(localConfig?.defaultEntry ?? packageJson?.pr?.defaultEntry);
+  if (defaultEntry && !entries.includes(defaultEntry) && scripts[`dev:${defaultEntry}`]) {
+    entries = [...entries, defaultEntry];
+  }
+  entries = dedupe(entries);
+  if (entries.length === 0) {
+    source = "none";
+  }
+  const scriptsByType = {};
+  for (const type of STANDARD_TYPES) {
+    const mapping = {};
+    for (const entry of entries) {
+      const scriptName = `${type}:${entry}`;
+      if (scripts[scriptName]) {
+        mapping[entry] = scriptName;
+      }
+    }
+    if (Object.keys(mapping).length > 0) {
+      scriptsByType[type] = mapping;
+    }
+  }
+  return {
+    isMpa: entries.length > 0,
+    entries,
+    defaultEntry: defaultEntry && entries.includes(defaultEntry) ? defaultEntry : void 0,
+    source,
+    scriptsByType
+  };
+}
+function normalizeEntryList(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return dedupe(value.map(normalizeEntryName).filter((item) => Boolean(item)));
+}
+function normalizeEntryName(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function collectEntriesByPrefix(scripts, prefix) {
+  const prefixWithColon = `${prefix}:`;
+  const entries = [];
+  for (const name of Object.keys(scripts)) {
+    if (!name.startsWith(prefixWithColon)) {
+      continue;
+    }
+    const entry = name.slice(prefixWithColon.length).trim();
+    if (!entry) {
+      continue;
+    }
+    entries.push(entry);
+  }
+  return dedupe(entries);
+}
 function findMatchingScript(scripts, patterns) {
   const scriptNames = Object.keys(scripts);
   for (const pattern of patterns) {
@@ -252,8 +326,12 @@ function findMatchingScript(scripts, patterns) {
       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")) {
+      const scriptContent = scripts[name];
+      if (!scriptContent) {
+        return false;
+      }
+      const content = scriptContent.toLowerCase();
+      if (content.includes("npm i") || content.includes("npm install") || content.includes("yarn install") || content.includes("pnpm install") || content.includes("bun install")) {
         return false;
       }
       return true;
@@ -264,6 +342,9 @@ function findMatchingScript(scripts, patterns) {
   }
   return void 0;
 }
+function dedupe(items) {
+  return [...new Set(items)];
+}
 
 // src/analyzer/dependencies.ts
 import { stat as stat2 } from "fs/promises";
@@ -329,34 +410,84 @@ async function getModifiedTime(path) {
   }
 }
 
+// src/analyzer/local-config.ts
+import { appendFile, readFile, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+var LOCAL_CONFIG_FILENAME = ".pr.local.json";
+async function loadPrLocalConfig(projectDir) {
+  const configPath = join3(projectDir, LOCAL_CONFIG_FILENAME);
+  if (!await fileExists(configPath)) {
+    return null;
+  }
+  let parsed;
+  try {
+    const content = await readFile(configPath, "utf-8");
+    parsed = JSON.parse(content.replace(/^\uFEFF/, ""));
+  } catch {
+    return null;
+  }
+  await ensureLocalConfigGitignored(projectDir);
+  if (!parsed || typeof parsed !== "object") {
+    return null;
+  }
+  const config = {};
+  if (Array.isArray(parsed.entries)) {
+    config.entries = parsed.entries.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0);
+  }
+  if (typeof parsed.defaultEntry === "string" && parsed.defaultEntry.trim()) {
+    config.defaultEntry = parsed.defaultEntry.trim();
+  }
+  return config;
+}
+async function ensureLocalConfigGitignored(projectDir) {
+  const gitignorePath = join3(projectDir, ".gitignore");
+  const ignoreEntry = LOCAL_CONFIG_FILENAME;
+  if (!await fileExists(gitignorePath)) {
+    await writeFile(gitignorePath, `${ignoreEntry}
+`, "utf-8");
+    return;
+  }
+  const content = await readFile(gitignorePath, "utf-8");
+  const lines = content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (lines.includes(ignoreEntry) || lines.includes(`/${ignoreEntry}`)) {
+    return;
+  }
+  const suffix = content.endsWith("\n") || content.length === 0 ? "" : "\n";
+  await appendFile(gitignorePath, `${suffix}${ignoreEntry}
+`, "utf-8");
+}
+
 // src/analyzer/index.ts
 async function analyzeProject(projectDir) {
-  const packageJsonPath = join3(projectDir, "package.json");
+  const packageJsonPath = join4(projectDir, "package.json");
   const hasPackageJson = await fileExists(packageJsonPath);
   if (!hasPackageJson) {
     return {
       type: "unknown",
       packageManager: { name: "npm", source: "default" },
       scripts: null,
-      dependencies: { hasNodeModules: false, needsInstall: false }
+      dependencies: { hasNodeModules: false, needsInstall: false },
+      localConfig: null
     };
   }
   let packageJson = {};
   try {
-    const content = await readFile(packageJsonPath, "utf-8");
-    packageJson = JSON.parse(content);
+    const content = await readFile2(packageJsonPath, "utf-8");
+    packageJson = JSON.parse(content.replace(/^\uFEFF/, ""));
   } catch {
   }
-  const [packageManager, dependencies] = await Promise.all([
+  const [packageManager, dependencies, localConfig] = await Promise.all([
     detectPackageManager(projectDir, packageJson),
-    checkDependencyStatus(projectDir)
+    checkDependencyStatus(projectDir),
+    loadPrLocalConfig(projectDir)
   ]);
-  const scripts = analyzeScripts(packageJson);
+  const scripts = analyzeScripts(packageJson, localConfig);
   return {
     type: "nodejs",
     packageManager,
     scripts,
     dependencies,
+    localConfig,
     name: packageJson.name,
     version: packageJson.version,
     description: packageJson.description
@@ -451,7 +582,7 @@ async function autoInstallPm(pm) {
 
 // src/cli/run.ts
 async function runCommand(projectDir, options = {}) {
-  const { noInstall = false, forceInstall = false, scriptType = "dev" } = options;
+  const { noInstall = false, forceInstall = false, scriptType = "dev", entry } = options;
   log("\u6B63\u5728\u5206\u6790\u9879\u76EE...");
   const project = await analyzeProject(projectDir);
   if (project.type === "unknown") {
@@ -462,10 +593,14 @@ async function runCommand(projectDir, options = {}) {
   if (!project.scripts) {
     throw new CliError("\u65E0\u6CD5\u8BFB\u53D6 package.json \u7684 scripts");
   }
-  const scriptName = findScript(project, scriptType);
+  const resolvedEntry = await resolveEntry(project, scriptType, entry);
+  const scriptName = findScript(project, scriptType, resolvedEntry);
   if (!scriptName) {
-    showAvailableScripts(project);
-    throw new CliError(`\u672A\u627E\u5230 ${scriptType} \u76F8\u5173\u7684\u811A\u672C`);
+    showAvailableScripts(project, scriptType, resolvedEntry);
+    throw new CliError(`\u672A\u627E\u5230 ${scriptType}${resolvedEntry ? `:${resolvedEntry}` : ""} \u76F8\u5173\u7684\u811A\u672C`);
+  }
+  if (resolvedEntry) {
+    log(`\u5165\u53E3: ${resolvedEntry}`);
   }
   log(`\u5C06\u6267\u884C\u811A\u672C: ${scriptName}`);
   const resolvedPm = await ensurePmAvailable(project.packageManager.name);
@@ -496,10 +631,16 @@ async function runCommand(projectDir, options = {}) {
     throw new CliError("\u811A\u672C\u6267\u884C\u5931\u8D25", exitCode);
   }
 }
-function findScript(project, scriptType) {
+function findScript(project, scriptType, entry) {
   const scripts = project.scripts;
   if (!scripts)
     return void 0;
+  if (entry) {
+    const entryScript = `${scriptType}:${entry}`;
+    if (scripts.scripts[entryScript]) {
+      return entryScript;
+    }
+  }
   const detected = scripts.detected[scriptType];
   if (detected) {
     return detected;
@@ -509,9 +650,115 @@ function findScript(project, scriptType) {
   }
   return void 0;
 }
-function showAvailableScripts(project) {
+async function resolveEntry(project, scriptType, entry) {
+  if (!project.scripts) {
+    return entry;
+  }
+  if (entry) {
+    validateEntry(project, scriptType, entry);
+    return entry;
+  }
+  if (scriptType !== "dev") {
+    return void 0;
+  }
+  const { mpa } = project.scripts;
+  if (!mpa.isMpa || mpa.entries.length === 0) {
+    return void 0;
+  }
+  if (mpa.entries.length === 1) {
+    const onlyEntry = mpa.entries[0];
+    if (onlyEntry) {
+      return onlyEntry;
+    }
+    return void 0;
+  }
+  const envEntry = process.env.PR_ENTRY?.trim();
+  if (envEntry) {
+    validateEntry(project, scriptType, envEntry);
+    return envEntry;
+  }
+  const defaultEntry = mpa.defaultEntry && hasEntryScript(project, scriptType, mpa.defaultEntry) ? mpa.defaultEntry : void 0;
+  if (!process.stdin.isTTY) {
+    if (defaultEntry) {
+      return defaultEntry;
+    }
+    throw new CliError(
+      `\u68C0\u6D4B\u5230 MPA \u5165\u53E3: ${mpa.entries.join(", ")}\u3002\u975E\u4EA4\u4E92\u73AF\u5883\u8BF7\u4F7F\u7528 --entry <name> \u6216\u8BBE\u7F6E PR_ENTRY\u3002`
+    );
+  }
+  return promptSelectEntry(project, scriptType, defaultEntry);
+}
+function validateEntry(project, scriptType, entry) {
+  if (!hasEntryScript(project, scriptType, entry)) {
+    const available = getAvailableEntriesByType(project, scriptType);
+    if (available.length > 0) {
+      throw new CliError(`\u5165\u53E3 "${entry}" \u4E0D\u5B58\u5728\u3002\u53EF\u9009\u5165\u53E3: ${available.join(", ")}`);
+    }
+    throw new CliError(`\u5165\u53E3 "${entry}" \u4E0D\u5B58\u5728\uFF0C\u4E14\u672A\u627E\u5230 ${scriptType}:<entry> \u811A\u672C`);
+  }
+}
+function hasEntryScript(project, scriptType, entry) {
+  const scripts = project.scripts;
+  if (!scripts)
+    return false;
+  return Boolean(scripts.scripts[`${scriptType}:${entry}`]);
+}
+function getAvailableEntriesByType(project, scriptType) {
+  const scripts = project.scripts;
+  if (!scripts)
+    return [];
+  const mapping = scripts.mpa.scriptsByType[scriptType];
+  if (!mapping)
+    return [];
+  return Object.keys(mapping);
+}
+async function promptSelectEntry(project, scriptType, defaultEntry) {
+  const entries = getAvailableEntriesByType(project, scriptType);
+  if (entries.length === 0) {
+    throw new CliError(`\u672A\u627E\u5230 ${scriptType}:<entry> \u811A\u672C\uFF0C\u65E0\u6CD5\u9009\u62E9 MPA \u5165\u53E3`);
+  }
+  const defaultResolved = defaultEntry && entries.includes(defaultEntry) ? defaultEntry : entries[0];
+  if (!defaultResolved) {
+    throw new CliError("\u672A\u627E\u5230\u53EF\u7528\u5165\u53E3\uFF0C\u65E0\u6CD5\u7EE7\u7EED\u6267\u884C");
+  }
+  info("\u68C0\u6D4B\u5230 MPA \u9879\u76EE\uFF0C\u8BF7\u9009\u62E9\u542F\u52A8\u5165\u53E3\uFF1A");
+  entries.forEach((item, index) => {
+    const marker = item === defaultResolved ? " (\u9ED8\u8BA4)" : "";
+    console.log(`  ${index + 1}) ${item}${marker}`);
+  });
+  console.log();
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(`\u8BF7\u8F93\u5165\u5E8F\u53F7 [1-${entries.length}]\uFF0C\u56DE\u8F66\u9ED8\u8BA4 ${defaultResolved}: `);
+    const trimmed = answer.trim();
+    if (!trimmed) {
+      return defaultResolved;
+    }
+    const number = Number(trimmed);
+    if (Number.isInteger(number) && number >= 1 && number <= entries.length) {
+      const selectedByNumber = entries[number - 1];
+      if (selectedByNumber) {
+        return selectedByNumber;
+      }
+    }
+    if (entries.includes(trimmed)) {
+      return trimmed;
+    }
+  } finally {
+    rl.close();
+  }
+  throw new CliError("\u65E0\u6548\u7684\u5165\u53E3\u9009\u62E9\uFF0C\u8BF7\u91CD\u65B0\u8FD0\u884C\u5E76\u8F93\u5165\u6B63\u786E\u5E8F\u53F7");
+}
+function showAvailableScripts(project, scriptType, entry) {
   if (!project.scripts)
     return;
+  if (entry) {
+    const availableEntries = getAvailableEntriesByType(project, scriptType);
+    if (availableEntries.length > 0) {
+      info(`\u53EF\u9009 ${scriptType} \u5165\u53E3: ${availableEntries.join(", ")}`);
+      return;
+    }
+  }
   const scriptNames = Object.keys(project.scripts.scripts);
   if (scriptNames.length === 0) {
     warn("package.json \u4E2D\u6CA1\u6709\u5B9A\u4E49\u4EFB\u4F55 scripts");
@@ -529,8 +776,8 @@ function showAvailableScripts(project) {
 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");
+    console.log(`${colors.red}\xD7${colors.reset} \u672A\u68C0\u6D4B\u5230\u9879\u76EE\u7C7B\u578B`);
+    console.log("  \u8BF7\u786E\u8BA4\u5F53\u524D\u76EE\u5F55\u5305\u542B package.json");
     return;
   }
   console.log();
@@ -558,6 +805,22 @@ async function infoCommand(projectDir) {
   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}`);
+  if (project.scripts) {
+    const { mpa } = project.scripts;
+    if (mpa.isMpa) {
+      const sourceLabel = mpa.source === "local-config" ? ".pr.local.json" : mpa.source === "package-json" ? "package.json#pr" : "scripts";
+      console.log(`${colors.bold}MPA \u6A21\u5F0F:${colors.reset} \u662F ${colors.dim}(${sourceLabel})${colors.reset}`);
+      console.log(`${colors.bold}\u53EF\u9009\u5165\u53E3:${colors.reset} ${mpa.entries.join(", ")}`);
+      if (mpa.defaultEntry) {
+        console.log(`${colors.bold}\u9ED8\u8BA4\u5165\u53E3:${colors.reset} ${mpa.defaultEntry}`);
+      }
+      if (project.localConfig) {
+        console.log(`${colors.bold}\u672C\u5730\u914D\u7F6E:${colors.reset} .pr.local.json ${colors.dim}(\u81EA\u52A8\u52A0\u5165 .gitignore)${colors.reset}`);
+      }
+    } else {
+      console.log(`${colors.bold}MPA \u6A21\u5F0F:${colors.reset} \u5426`);
+    }
+  }
   console.log();
   if (project.scripts) {
     const { scripts, detected } = project.scripts;
@@ -580,7 +843,10 @@ async function infoCommand(projectDir) {
       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;
+        if (!cmd) {
+          continue;
+        }
+        const displayCmd = cmd.length > 60 ? cmd.slice(0, 60) + "..." : cmd;
         console.log(`  ${colors.cyan}${name}${colors.reset} ${colors.dim}\u2192 ${displayCmd}${colors.reset}`);
       }
     }
@@ -624,7 +890,7 @@ function showAvailableScripts2(scripts) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.2.0" : "0.0.0-dev";
+var VERSION = true ? "0.3.0" : "0.0.0-dev";
 function parseArgs(args) {
   const options = {
     verbose: false,
@@ -637,14 +903,30 @@ function parseArgs(args) {
   let i = 0;
   while (i < args.length) {
     const arg = args[i];
+    if (!arg) {
+      i++;
+      continue;
+    }
     if (arg === "-v" || arg === "--verbose") {
       options.verbose = true;
     } else if (arg === "-d" || arg === "--dir") {
-      options.dir = resolve(args[++i] || ".");
+      const dirArg = args[i + 1];
+      if (!dirArg || dirArg.startsWith("-")) {
+        throw new CliError("--dir \u9700\u8981\u4E00\u4E2A\u76EE\u5F55\u53C2\u6570");
+      }
+      options.dir = resolve(dirArg);
+      i++;
     } else if (arg === "--no-install") {
       options.noInstall = true;
     } else if (arg === "-i" || arg === "--install") {
       options.install = true;
+    } else if (arg === "-e" || arg === "--entry") {
+      const entryArg = args[i + 1];
+      if (!entryArg || entryArg.startsWith("-")) {
+        throw new CliError("--entry \u9700\u8981\u4E00\u4E2A\u5165\u53E3\u540D\u53C2\u6570");
+      }
+      options.entry = entryArg.trim();
+      i++;
     } else if (arg === "-h" || arg === "--help") {
       command = "help";
     } else if (arg === "-V" || arg === "--version") {
@@ -669,7 +951,7 @@ ${"\x1B[36m"}pr${"\x1B[0m"} v${VERSION} - \u96F6\u914D\u7F6E\u667A\u80FD\u9879\u
 ${"\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
+  run              \u5B8C\u6574\u6D41\u7A0B\uFF1A\u68C0\u6D4B -> install -> \u542F\u52A8\u5F00\u53D1\u811A\u672C
   test             \u8FD0\u884C\u6D4B\u8BD5
   build            \u6784\u5EFA\u9879\u76EE
   start            \u751F\u4EA7\u6A21\u5F0F\u542F\u52A8
@@ -681,16 +963,16 @@ ${"\x1B[1m"}\u9009\u9879:${"\x1B[0m"}
   -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
+  -e, --entry      \u6307\u5B9A MPA \u5165\u53E3 (\u4E5F\u53EF\u7528\u73AF\u5883\u53D8\u91CF PR_ENTRY)
   -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
+  pr run
+  pr run --entry main
+  PR_ENTRY=formengine pr run
+  pr build --entry approve
+  pr info
 `);
 }
 function showVersion() {
@@ -698,7 +980,7 @@ function showVersion() {
 }
 async function main() {
   setupSignalHandlers();
-  const { command, options, args } = parseArgs(process.argv.slice(2));
+  const { command, options } = parseArgs(process.argv.slice(2));
   setVerbose(options.verbose);
   switch (command) {
     case "":
@@ -709,16 +991,33 @@ async function main() {
       showVersion();
       break;
     case "run":
-      await runCommand(options.dir, { noInstall: options.noInstall, forceInstall: options.install, scriptType: "dev" });
+      await runCommand(options.dir, {
+        noInstall: options.noInstall,
+        forceInstall: options.install,
+        scriptType: "dev",
+        entry: options.entry
+      });
       break;
     case "test":
-      await runCommand(options.dir, { noInstall: true, scriptType: "test" });
+      await runCommand(options.dir, {
+        noInstall: true,
+        scriptType: "test",
+        entry: options.entry
+      });
       break;
     case "build":
-      await runCommand(options.dir, { noInstall: true, scriptType: "build" });
+      await runCommand(options.dir, {
+        noInstall: true,
+        scriptType: "build",
+        entry: options.entry
+      });
       break;
     case "start":
-      await runCommand(options.dir, { noInstall: true, scriptType: "start" });
+      await runCommand(options.dir, {
+        noInstall: true,
+        scriptType: "start",
+        entry: options.entry
+      });
       break;
     case "info":
       await infoCommand(options.dir);

package/package.json

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