project-runner 0.1.0 → 0.1.2

package/src/analyzer/dependencies.ts

@@ -1,118 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,119 +0,0 @@
-// 包管理器类型
-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

@@ -1,98 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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}`)
-  }
-}