project-runner 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 liangzhenqi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,172 @@
+# project-runner (pr)
+
+零配置智能项目运行器 - 一键运行任意 Node.js 项目
+
+[![npm version](https://img.shields.io/npm/v/project-runner.svg)](https://www.npmjs.com/package/project-runner)
+[![license](https://img.shields.io/npm/l/project-runner.svg)](https://github.com/liangzhenqi/project-runner/blob/main/LICENSE)
+
+## 特性
+
+- **零配置** - 自动检测项目类型和包管理器
+- **智能识别** - 支持 npm / yarn / pnpm / bun
+- **一键运行** - 自动安装依赖并启动项目
+- **跨平台** - 支持 Windows / macOS / Linux
+
+## 安装
+
+```bash
+# 使用 npm
+npm install -g project-runner
+
+# 使用 bun
+bun install -g project-runner
+```
+
+## 使用
+
+```bash
+# 一键运行项目（自动 install + 启动开发服务器）
+pr run
+
+# 显示详细检测过程
+pr run -v
+
+# 跳过依赖安装
+pr run --no-install
+
+# 运行测试
+pr test
+
+# 构建项目
+pr build
+
+# 生产模式启动
+pr start
+
+# 运行任意 package.json 脚本
+pr lint
+pr custom-script
+
+# 查看项目信息
+pr info
+```
+
+## 工作原理
+
+`pr run` 执行以下完整流程：
+
+```
+1. 检测项目类型 (Node.js / Python)
+2. 检测包管理器 (npm / yarn / pnpm / bun)
+   - 优先级: packageManager 字段 > volta 字段 > lockfile
+3. 检测依赖状态
+   - node_modules 是否存在
+   - lockfile 是否更新
+4. 安装依赖（如需要）
+5. 读取 scripts，确定启动命令
+6. 启动项目
+```
+
+## 包管理器检测
+
+`pr` 通过以下方式检测包管理器（按优先级排序）：
+
+1. **packageManager 字段** (corepack)
+   ```json
+   { "packageManager": "pnpm@9.1.0" }
+   ```
+
+2. **volta 字段**
+   ```json
+   { "volta": { "pnpm": "9.1.0" } }
+   ```
+
+3. **Lockfile 检测**
+   - `bun.lockb` / `bun.lock` → bun
+   - `pnpm-lock.yaml` → pnpm
+   - `yarn.lock` → yarn
+   - `package-lock.json` → npm
+
+## 命令
+
+| 命令 | 说明 |
+|------|------|
+| `pr run` | 完整流程：检测 → install → 启动开发服务器 |
+| `pr test` | 运行测试 |
+| `pr build` | 构建项目 |
+| `pr start` | 生产模式启动 |
+| `pr info` | 显示项目分析结果 |
+| `pr <script>` | 运行 package.json 中的任意脚本 |
+
+## 选项
+
+| 选项 | 说明 |
+|------|------|
+| `-v, --verbose` | 显示详细检测过程 |
+| `-d, --dir <path>` | 指定项目目录（默认：当前目录）|
+| `--no-install` | 跳过依赖安装步骤 |
+| `-h, --help` | 显示帮助信息 |
+| `-V, --version` | 显示版本号 |
+
+## 示例输出
+
+### `pr info`
+
+```
+pr - 项目分析结果
+────────────────────────────────────────
+项目名称: my-app
+版本:     1.0.0
+项目类型: nodejs
+包管理器: pnpm (lockfile)
+依赖状态: 已就绪
+
+识别的命令:
+  pr run   → pnpm dev
+  pr test  → pnpm test
+  pr build → pnpm build
+
+所有脚本:
+  dev → vite
+  test → vitest
+  build → tsc && vite build
+  lint → eslint .
+```
+
+### `pr run -v`
+
+```
+[pr] 正在分析项目...
+[pr] 项目类型: nodejs
+[pr] 包管理器: pnpm (from lockfile)
+[pr] 将执行脚本: dev
+[pr] 依赖状态: 已是最新
+> pnpm dev
+
+> my-app@1.0.0 dev
+> vite
+
+  VITE v5.0.0  ready in 300 ms
+  ➜  Local:   http://localhost:5173/
+```
+
+## 开发
+
+```bash
+# 克隆项目
+git clone https://github.com/liangzhenqi/project-runner.git
+cd project-runner
+
+# 安装依赖
+bun install
+
+# 本地运行
+bun run dev
+
+# 链接到全局
+bun link
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "project-runner",
+  "version": "0.1.0",
+  "description": "零配置智能项目运行器 - 一键运行任意 Node.js 项目",
+  "author": "liangzhenqi",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/liangzhenqi/project-runner.git"
+  },
+  "keywords": [
+    "cli",
+    "runner",
+    "project",
+    "npm",
+    "yarn",
+    "pnpm",
+    "bun",
+    "dev",
+    "build",
+    "test"
+  ],
+  "module": "src/index.ts",
+  "type": "module",
+  "bin": {
+    "pr": "src/index.ts"
+  },
+  "files": [
+    "src",
+    "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'"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/analyzer/dependencies.ts

@@ -0,0 +1,118 @@
+import { stat } from 'fs/promises'
+import { join } from 'path'
+
+export interface DependencyStatus {
+  hasNodeModules: boolean
+  needsInstall: boolean
+  reason?: string
+}
+
+// Lockfile 列表
+const LOCKFILES = [
+  'bun.lockb',
+  'bun.lock',
+  'pnpm-lock.yaml',
+  'yarn.lock',
+  'package-lock.json',
+]
+
+/**
+ * 检测项目的依赖状态
+ * 判断是否需要执行 install
+ */
+export async function checkDependencyStatus(projectDir: string): Promise<DependencyStatus> {
+  const nodeModulesPath = join(projectDir, 'node_modules')
+
+  // 1. 检查 node_modules 是否存在
+  const nodeModulesExists = await directoryExists(nodeModulesPath)
+  if (!nodeModulesExists) {
+    return {
+      hasNodeModules: false,
+      needsInstall: true,
+      reason: 'node_modules 不存在',
+    }
+  }
+
+  // 2. 检查 lockfile 是否比 node_modules 更新
+  const lockfilePath = await findLockfile(projectDir)
+  if (lockfilePath) {
+    const lockfileMtime = await getModifiedTime(lockfilePath)
+    const nodeModulesMtime = await getModifiedTime(nodeModulesPath)
+
+    if (lockfileMtime && nodeModulesMtime && lockfileMtime > nodeModulesMtime) {
+      return {
+        hasNodeModules: true,
+        needsInstall: true,
+        reason: 'lockfile 已更新',
+      }
+    }
+  }
+
+  // 3. 检查 package.json 是否比 node_modules 更新
+  const packageJsonPath = join(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 已更新',
+    }
+  }
+
+  // 依赖状态正常
+  return {
+    hasNodeModules: true,
+    needsInstall: false,
+  }
+}
+
+/**
+ * 查找项目中的 lockfile
+ */
+async function findLockfile(projectDir: string): Promise<string | null> {
+  for (const lockfile of LOCKFILES) {
+    const lockfilePath = join(projectDir, lockfile)
+    if (await fileExists(lockfilePath)) {
+      return lockfilePath
+    }
+  }
+  return null
+}
+
+/**
+ * 获取文件/目录的修改时间
+ */
+async function getModifiedTime(path: string): Promise<number | null> {
+  try {
+    const stats = await stat(path)
+    return stats.mtimeMs
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 检查目录是否存在
+ */
+async function directoryExists(path: string): Promise<boolean> {
+  try {
+    const stats = await stat(path)
+    return stats.isDirectory()
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 检查文件是否存在
+ */
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    const stats = await stat(path)
+    return stats.isFile()
+  } catch {
+    return false
+  }
+}

package/src/analyzer/index.ts

@@ -0,0 +1,56 @@
+import { detectPackageManager, type PackageManagerInfo } from './package-manager'
+import { analyzeScripts, type ScriptsInfo } from './scripts'
+import { checkDependencyStatus, type DependencyStatus } from './dependencies'
+
+export interface ProjectInfo {
+  type: 'nodejs' | 'python' | 'unknown'
+  packageManager: PackageManagerInfo
+  scripts: ScriptsInfo | null
+  dependencies: DependencyStatus
+  name?: string
+  version?: string
+  description?: string
+}
+
+/**
+ * 分析项目，获取完整的项目信息
+ */
+export async function analyzeProject(projectDir: string): Promise<ProjectInfo> {
+  // 检测项目类型（目前仅支持 Node.js）
+  const packageJsonPath = `${projectDir}/package.json`
+  const hasPackageJson = await Bun.file(packageJsonPath).exists()
+
+  if (!hasPackageJson) {
+    return {
+      type: 'unknown',
+      packageManager: { name: 'npm', source: 'default' },
+      scripts: null,
+      dependencies: { hasNodeModules: false, needsInstall: false },
+    }
+  }
+
+  // 读取 package.json 基本信息
+  const packageJson = await Bun.file(packageJsonPath).json().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,
+  }
+}
+
+// 导出子模块
+export { detectPackageManager, type PackageManagerInfo } from './package-manager'
+export { analyzeScripts, type ScriptsInfo, getAvailableScripts, hasScript } from './scripts'
+export { checkDependencyStatus, type DependencyStatus } from './dependencies'

package/src/analyzer/package-manager.ts

@@ -0,0 +1,119 @@
+// 包管理器类型
+export type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun'
+
+// 包管理器检测来源
+export type DetectionSource = 'packageManager' | 'volta' | 'lockfile' | 'default'
+
+export interface PackageManagerInfo {
+  name: PackageManager
+  version?: string
+  source: DetectionSource
+}
+
+// Lockfile 检测映射
+const LOCKFILE_MAP: Record<string, PackageManager> = {
+  'bun.lockb': 'bun',
+  'bun.lock': 'bun',
+  'pnpm-lock.yaml': 'pnpm',
+  'yarn.lock': 'yarn',
+  'package-lock.json': 'npm',
+}
+
+/**
+ * 检测项目使用的包管理器
+ * 优先级: packageManager 字段 > volta 字段 > lockfile
+ */
+export async function detectPackageManager(projectDir: string): Promise<PackageManagerInfo> {
+  const packageJsonPath = `${projectDir}/package.json`
+
+  // 读取 package.json
+  const packageJson = await readPackageJson(packageJsonPath)
+  if (!packageJson) {
+    return { name: 'npm', source: 'default' }
+  }
+
+  // 1. 检查 packageManager 字段 (corepack)
+  if (packageJson.packageManager) {
+    const match = packageJson.packageManager.match(/^(npm|yarn|pnpm|bun)@(.+)$/)
+    if (match) {
+      return {
+        name: match[1] as PackageManager,
+        version: match[2],
+        source: 'packageManager',
+      }
+    }
+  }
+
+  // 2. 检查 volta 字段
+  if (packageJson.volta) {
+    for (const pm of ['pnpm', 'yarn', 'npm'] as PackageManager[]) {
+      if (packageJson.volta[pm]) {
+        return {
+          name: pm,
+          version: packageJson.volta[pm],
+          source: 'volta',
+        }
+      }
+    }
+  }
+
+  // 3. 检测 lockfile
+  for (const [lockfile, pm] of Object.entries(LOCKFILE_MAP)) {
+    const exists = await Bun.file(`${projectDir}/${lockfile}`).exists()
+    if (exists) {
+      return { name: pm, source: 'lockfile' }
+    }
+  }
+
+  // 默认使用 npm
+  return { name: 'npm', source: 'default' }
+}
+
+/**
+ * 获取包管理器的运行命令
+ */
+export function getRunCommand(pm: PackageManager, script: string): string[] {
+  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]
+  }
+}
+
+/**
+ * 获取包管理器的安装命令
+ */
+export function getInstallCommand(pm: PackageManager): string[] {
+  switch (pm) {
+    case 'bun':
+      return ['bun', 'install']
+    case 'pnpm':
+      return ['pnpm', 'install']
+    case 'yarn':
+      return ['yarn', 'install']
+    case 'npm':
+    default:
+      return ['npm', 'install']
+  }
+}
+
+/**
+ * 读取 package.json
+ */
+async function readPackageJson(path: string): Promise<any | null> {
+  try {
+    const file = Bun.file(path)
+    if (await file.exists()) {
+      return await file.json()
+    }
+  } catch {
+    // 忽略错误
+  }
+  return null
+}

package/src/analyzer/scripts.ts

@@ -0,0 +1,98 @@
+export interface ScriptsInfo {
+  scripts: Record<string, string>
+  // 识别出的主要命令（dev, test, build, start）
+  detected: {
+    dev?: string      // 开发启动脚本名
+    test?: string     // 测试脚本名
+    build?: string    // 构建脚本名
+    start?: string    // 生产启动脚本名
+  }
+}
+
+// 开发命令的常见名称（按优先级排序）
+const DEV_PATTERNS = ['dev', 'serve', 'start:dev', 'develop', 'watch']
+
+// 测试命令的常见名称
+const TEST_PATTERNS = ['test', 'test:unit', 'test:all', 'spec']
+
+// 构建命令的常见名称
+const BUILD_PATTERNS = ['build', 'compile', 'bundle', 'dist']
+
+// 生产启动命令的常见名称
+const START_PATTERNS = ['start', 'serve', 'preview', 'production']
+
+/**
+ * 读取并分析 package.json 的 scripts 字段
+ */
+export async function analyzeScripts(projectDir: string): Promise<ScriptsInfo | null> {
+  const packageJsonPath = `${projectDir}/package.json`
+
+  try {
+    const file = Bun.file(packageJsonPath)
+    if (!await file.exists()) {
+      return null
+    }
+
+    const packageJson = await file.json()
+    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
+  }
+}
+
+/**
+ * 从 scripts 中找到匹配的脚本名
+ * @param scripts package.json 的 scripts 对象
+ * @param patterns 要匹配的模式列表（按优先级排序）
+ */
+function findMatchingScript(scripts: Record<string, string>, patterns: string[]): string | undefined {
+  const scriptNames = Object.keys(scripts)
+
+  // 按优先级检查每个模式
+  for (const pattern of patterns) {
+    // 精确匹配
+    if (scripts[pattern]) {
+      return pattern
+    }
+    // 模糊匹配（包含模式的脚本名）
+    const fuzzyMatch = scriptNames.find(name =>
+      name.toLowerCase().includes(pattern.toLowerCase())
+    )
+    if (fuzzyMatch) {
+      return fuzzyMatch
+    }
+  }
+
+  return undefined
+}
+
+/**
+ * 获取所有可用的脚本列表
+ */
+export function getAvailableScripts(scriptsInfo: ScriptsInfo): string[] {
+  return Object.keys(scriptsInfo.scripts)
+}
+
+/**
+ * 检查脚本是否存在
+ */
+export function hasScript(scriptsInfo: ScriptsInfo, scriptName: string): boolean {
+  return scriptName in scriptsInfo.scripts
+}
+
+/**
+ * 获取脚本的实际命令内容
+ */
+export function getScriptCommand(scriptsInfo: ScriptsInfo, scriptName: string): string | undefined {
+  return scriptsInfo.scripts[scriptName]
+}

package/src/cli/info.ts

@@ -0,0 +1,87 @@
+import { analyzeProject } from '../analyzer'
+import { colors } from '../utils/log'
+
+/**
+ * pr info 命令
+ * 显示项目分析结果
+ */
+export async function infoCommand(projectDir: string) {
+  const project = await analyzeProject(projectDir)
+
+  if (project.type === 'unknown') {
+    console.log(`${colors.red}✗${colors.reset} 未检测到项目类型`)
+    console.log('  请确保当前目录包含 package.json 或其他项目配置文件')
+    return
+  }
+
+  // 项目基本信息
+  console.log()
+  console.log(`${colors.cyan}${colors.bold}pr - 项目分析结果${colors.reset}`)
+  console.log('─'.repeat(40))
+
+  if (project.name) {
+    console.log(`${colors.bold}项目名称:${colors.reset} ${project.name}`)
+  }
+  if (project.version) {
+    console.log(`${colors.bold}版本:${colors.reset}     ${project.version}`)
+  }
+  if (project.description) {
+    console.log(`${colors.bold}描述:${colors.reset}     ${project.description}`)
+  }
+
+  console.log(`${colors.bold}项目类型:${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}包管理器:${colors.reset} ${pmInfo}`)
+
+  // 依赖状态
+  const deps = project.dependencies
+  const depsStatus = deps.needsInstall
+    ? `${colors.yellow}需要安装${colors.reset} (${deps.reason})`
+    : `${colors.green}已就绪${colors.reset}`
+  console.log(`${colors.bold}依赖状态:${colors.reset} ${depsStatus}`)
+
+  console.log()
+
+  // Scripts 信息
+  if (project.scripts) {
+    const { scripts, detected } = project.scripts
+
+    // 显示识别的主要命令
+    console.log(`${colors.bold}识别的命令:${colors.reset}`)
+    if (detected.dev) {
+      console.log(`  ${colors.green}pr run${colors.reset}   → ${pm.name} ${detected.dev}`)
+    }
+    if (detected.test) {
+      console.log(`  ${colors.green}pr test${colors.reset}  → ${pm.name} ${detected.test}`)
+    }
+    if (detected.build) {
+      console.log(`  ${colors.green}pr build${colors.reset} → ${pm.name} ${detected.build}`)
+    }
+    if (detected.start) {
+      console.log(`  ${colors.green}pr start${colors.reset} → ${pm.name} ${detected.start}`)
+    }
+
+    console.log()
+
+    // 显示所有可用脚本
+    const allScripts = Object.keys(scripts)
+    if (allScripts.length > 0) {
+      console.log(`${colors.bold}所有脚本:${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}→ ${displayCmd}${colors.reset}`)
+      }
+    }
+  }
+
+  console.log()
+}

package/src/cli/run.ts

@@ -0,0 +1,117 @@
+import { analyzeProject, type ProjectInfo } from '../analyzer'
+import { getRunCommand, getInstallCommand } from '../analyzer/package-manager'
+import { execute } from '../runner/executor'
+import { log, error, warn, success, info, newline } from '../utils/log'
+
+type ScriptType = 'dev' | 'test' | 'build' | 'start'
+
+interface RunOptions {
+  noInstall?: boolean
+  scriptType?: ScriptType
+}
+
+/**
+ * qy run 命令
+ * 完整流程：检测 → install → 启动
+ */
+export async function runCommand(projectDir: string, options: RunOptions = {}) {
+  const { noInstall = false, scriptType = 'dev' } = options
+
+  // 1. 分析项目
+  log('正在分析项目...')
+  const project = await analyzeProject(projectDir)
+
+  if (project.type === 'unknown') {
+    error('未检测到项目类型。请确保当前目录包含 package.json')
+    process.exit(1)
+  }
+
+  // 2. 输出检测结果
+  log(`项目类型: ${project.type}`)
+  log(`包管理器: ${project.packageManager.name} (from ${project.packageManager.source})`)
+
+  if (!project.scripts) {
+    error('无法读取 package.json 的 scripts')
+    process.exit(1)
+  }
+
+  // 3. 确定要执行的脚本
+  const scriptName = findScript(project, scriptType)
+
+  if (!scriptName) {
+    error(`未找到 ${scriptType} 相关的脚本`)
+    showAvailableScripts(project)
+    process.exit(1)
+  }
+
+  log(`将执行脚本: ${scriptName}`)
+
+  // 4. 检查依赖状态，决定是否需要 install
+  if (!noInstall && project.dependencies.needsInstall) {
+    log(`依赖状态: ${project.dependencies.reason || '需要安装'}`)
+    newline()
+
+    // 执行 install
+    const installCmd = getInstallCommand(project.packageManager.name)
+    const installExitCode = await execute(installCmd, { cwd: projectDir })
+
+    if (installExitCode !== 0) {
+      error('依赖安装失败')
+      process.exit(installExitCode)
+    }
+
+    success('依赖安装完成')
+    newline()
+  } else if (!noInstall) {
+    log('依赖状态: 已是最新')
+  }
+
+  // 5. 执行脚本
+  const runCmd = getRunCommand(project.packageManager.name, scriptName)
+  const exitCode = await execute(runCmd, { cwd: projectDir })
+
+  if (exitCode !== 0) {
+    process.exit(exitCode)
+  }
+}
+
+/**
+ * 根据脚本类型找到对应的脚本名
+ */
+function findScript(project: ProjectInfo, scriptType: ScriptType): string | undefined {
+  const scripts = project.scripts
+  if (!scripts) return undefined
+
+  // 使用智能检测的结果
+  const detected = scripts.detected[scriptType]
+  if (detected) {
+    return detected
+  }
+
+  // 如果没有检测到，尝试精确匹配
+  if (scripts.scripts[scriptType]) {
+    return scriptType
+  }
+
+  return undefined
+}
+
+/**
+ * 显示可用的脚本列表
+ */
+function showAvailableScripts(project: ProjectInfo) {
+  if (!project.scripts) return
+
+  const scriptNames = Object.keys(project.scripts.scripts)
+  if (scriptNames.length === 0) {
+    warn('package.json 中没有定义任何 scripts')
+    return
+  }
+
+  info('可用的脚本:')
+  for (const name of scriptNames) {
+    console.log(`  - ${name}`)
+  }
+  console.log()
+  info('使用 qy <script> 运行任意脚本')
+}

package/src/cli/script.ts

@@ -0,0 +1,59 @@
+import { analyzeProject } from '../analyzer'
+import { getRunCommand } from '../analyzer/package-manager'
+import { execute } from '../runner/executor'
+import { error, log, info } from '../utils/log'
+
+/**
+ * 运行任意 package.json 脚本
+ */
+export async function scriptCommand(projectDir: string, scriptName: string) {
+  // 分析项目
+  const project = await analyzeProject(projectDir)
+
+  if (project.type === 'unknown') {
+    error('未检测到项目类型。请确保当前目录包含 package.json')
+    process.exit(1)
+  }
+
+  if (!project.scripts) {
+    error('无法读取 package.json 的 scripts')
+    process.exit(1)
+  }
+
+  // 检查脚本是否存在
+  const scripts = project.scripts.scripts
+  if (!(scriptName in scripts)) {
+    error(`脚本 "${scriptName}" 不存在`)
+    console.log()
+    showAvailableScripts(scripts)
+    process.exit(1)
+  }
+
+  log(`包管理器: ${project.packageManager.name}`)
+  log(`执行脚本: ${scriptName}`)
+
+  // 执行脚本
+  const runCmd = getRunCommand(project.packageManager.name, scriptName)
+  const exitCode = await execute(runCmd, { cwd: projectDir })
+
+  if (exitCode !== 0) {
+    process.exit(exitCode)
+  }
+}
+
+/**
+ * 显示可用脚本列表
+ */
+function showAvailableScripts(scripts: Record<string, string>) {
+  const scriptNames = Object.keys(scripts)
+
+  if (scriptNames.length === 0) {
+    info('package.json 中没有定义任何脚本')
+    return
+  }
+
+  info('可用的脚本:')
+  for (const name of scriptNames) {
+    console.log(`  - ${name}`)
+  }
+}

package/src/index.ts

@@ -0,0 +1,141 @@
+#!/usr/bin/env bun
+
+import { resolve } from 'path'
+import { setVerbose, error, info } from './utils/log'
+import { setupSignalHandlers } from './runner/executor'
+import { runCommand } from './cli/run'
+import { infoCommand } from './cli/info'
+import { scriptCommand } from './cli/script'
+
+const VERSION = '0.1.0'
+
+interface CliOptions {
+  verbose: boolean
+  dir: string
+  noInstall: boolean
+}
+
+function parseArgs(args: string[]): { command: string; options: CliOptions; args: string[] } {
+  const options: CliOptions = {
+    verbose: false,
+    dir: process.cwd(),
+    noInstall: false,
+  }
+
+  let command = ''
+  const remainingArgs: string[] = []
+  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 === '-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} - 零配置智能项目运行器 (project-runner)
+
+${'\x1b[1m'}用法:${'\x1b[0m'} pr <command> [options]
+
+${'\x1b[1m'}命令:${'\x1b[0m'}
+  run              完整流程：检测 → install → 启动开发服务器
+  test             运行测试
+  build            构建项目
+  start            生产模式启动
+  info             显示项目分析结果
+  <script>         运行 package.json 中的任意脚本
+
+${'\x1b[1m'}选项:${'\x1b[0m'}
+  -v, --verbose    显示详细检测过程
+  -d, --dir <path> 指定项目目录 (默认: 当前目录)
+  --no-install     跳过依赖安装步骤
+  -h, --help       显示帮助信息
+  -V, --version    显示版本号
+
+${'\x1b[1m'}示例:${'\x1b[0m'}
+  pr run           一键启动项目
+  pr run -v        显示详细检测过程
+  pr test          运行测试
+  pr lint          运行 lint 脚本
+  pr info          查看项目信息
+`)
+}
+
+function showVersion() {
+  console.log(`pr v${VERSION}`)
+}
+
+async function main() {
+  // 设置信号处理
+  setupSignalHandlers()
+
+  // 解析命令行参数
+  const { command, options, args } = parseArgs(process.argv.slice(2))
+
+  // 设置 verbose 模式
+  setVerbose(options.verbose)
+
+  // 处理命令
+  switch (command) {
+    case '':
+    case 'help':
+      showHelp()
+      break
+
+    case 'version':
+      showVersion()
+      break
+
+    case 'run':
+      await runCommand(options.dir, { noInstall: options.noInstall, 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/src/runner/executor.ts

@@ -0,0 +1,93 @@
+import { spawn, type Subprocess } from 'bun'
+import { execLog } from '../utils/log'
+
+let currentProcess: Subprocess | null = null
+
+/**
+ * 执行命令
+ * @param cmd 命令数组 ['npm', 'run', 'dev']
+ * @param options 选项
+ */
+export async function execute(
+  cmd: string[],
+  options: {
+    cwd?: string
+    env?: Record<string, string>
+    silent?: boolean
+  } = {}
+): Promise<number> {
+  const { cwd = process.cwd(), env, silent = false } = options
+
+  if (!silent) {
+    execLog(cmd.join(' '))
+  }
+
+  // 启动子进程
+  currentProcess = spawn({
+    cmd,
+    cwd,
+    env: { ...process.env, ...env },
+    stdio: ['inherit', 'inherit', 'inherit'],
+  })
+
+  // 等待进程结束
+  const exitCode = await currentProcess.exited
+  currentProcess = null
+
+  return exitCode
+}
+
+/**
+ * 执行命令并返回输出
+ */
+export async function executeCapture(
+  cmd: string[],
+  options: {
+    cwd?: string
+    env?: Record<string, string>
+  } = {}
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  const { cwd = process.cwd(), env } = options
+
+  const proc = spawn({
+    cmd,
+    cwd,
+    env: { ...process.env, ...env },
+    stdout: 'pipe',
+    stderr: 'pipe',
+  })
+
+  const stdout = await new Response(proc.stdout).text()
+  const stderr = await new Response(proc.stderr).text()
+  const exitCode = await proc.exited
+
+  return { stdout, stderr, exitCode }
+}
+
+/**
+ * 设置信号处理器
+ */
+export function setupSignalHandlers() {
+  // Ctrl+C 处理
+  process.on('SIGINT', () => {
+    if (currentProcess) {
+      currentProcess.kill()
+    }
+    process.exit(0)
+  })
+
+  // SIGTERM 处理
+  process.on('SIGTERM', () => {
+    if (currentProcess) {
+      currentProcess.kill()
+    }
+    process.exit(0)
+  })
+}
+
+/**
+ * 获取当前运行的进程
+ */
+export function getCurrentProcess(): Subprocess | null {
+  return currentProcess
+}

package/src/utils/log.ts

@@ -0,0 +1,86 @@
+// ANSI 颜色代码
+const 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',
+}
+
+// 全局 verbose 状态
+let isVerbose = false
+
+export function setVerbose(verbose: boolean) {
+  isVerbose = verbose
+}
+
+export function getVerbose(): boolean {
+  return isVerbose
+}
+
+/**
+ * 日志函数（仅在 verbose 模式下输出）
+ */
+export function log(message: string) {
+  if (isVerbose) {
+    console.log(`${colors.cyan}[pr]${colors.reset} ${message}`)
+  }
+}
+
+/**
+ * 信息日志（始终输出）
+ */
+export function info(message: string) {
+  console.log(`${colors.cyan}[pr]${colors.reset} ${message}`)
+}
+
+/**
+ * 成功日志
+ */
+export function success(message: string) {
+  console.log(`${colors.green}✓${colors.reset} ${message}`)
+}
+
+/**
+ * 警告日志
+ */
+export function warn(message: string) {
+  console.log(`${colors.yellow}⚠${colors.reset} ${message}`)
+}
+
+/**
+ * 错误日志
+ */
+export function error(message: string) {
+  console.error(`${colors.red}✗${colors.reset} ${message}`)
+}
+
+/**
+ * 执行命令的日志
+ */
+export function execLog(command: string) {
+  console.log(`${colors.dim}>${colors.reset} ${colors.bold}${command}${colors.reset}`)
+}
+
+/**
+ * 输出空行
+ */
+export function newline() {
+  console.log()
+}
+
+/**
+ * 输出带颜色的文本
+ */
+export function colorize(text: string, color: keyof typeof colors): string {
+  return `${colors[color]}${text}${colors.reset}`
+}
+
+export { colors }