ai-code-review-kit 1.1.2

package/src/ai-review.js

@@ -0,0 +1,392 @@
+#!/usr/bin/env node
+
+import { execFileSync } from 'child_process'
+import chalk from 'chalk'
+import fs from 'fs'
+import path from 'path'
+import CodeReviewer from './core.js'
+import AIError from './AIError.js'
+import { fileURLToPath } from 'url'
+
+const defaultConfig = {
+  providerType: 'OPENAI',
+  model: '',
+  baseURL: '',
+  useResponsesApi: false,
+
+  timeoutMs: 120000,
+  concurrency: 2,
+  maxRetries: 1,
+  retryDelayMs: 500,
+
+  ignoreDeletions: true,
+  stripUnchangedCommentLines: true,
+
+  diffContextLines: 3,
+  maxChunkSize: 12000,
+  temperature: 0.2,
+  language: 'chinese',
+  strict: true,
+  skipReview: false,
+  showNormal: false,
+  correctedResult: true,
+  customPrompts: '',
+  enabledFileExtensions: '.html, .js, .jsx, .ts, .tsx, .vue',
+
+  checkSecurity: true,
+  checkPerformance: true,
+  checkStyle: false,
+
+  enableRag: false,
+  knowledgeBasePaths: '',
+  knowledgeBaseIndexDir: '.ai-reviewer-cache/lancedb',
+  knowledgeBaseTable: 'project_kb',
+  ragTopK: 6,
+  ragMaxChars: 8000,
+  embeddingsProviderType: '',
+  embeddingsBaseURL: '',
+  embeddingsApiKey: '',
+  embeddingsModel: '',
+  embeddingsDimensions: null,
+  kbChunkSize: 1500,
+  kbChunkOverlap: 200,
+  kbMaxFileSizeBytes: 524288
+}
+
+function runGit(args, options = {}) {
+  return execFileSync('git', args, { encoding: 'utf8', ...options }).trim()
+}
+
+function getGitRoot() {
+  try {
+    return runGit(['rev-parse', '--show-toplevel'], { cwd: process.cwd() })
+  } catch {
+    handleError('Git error:', 'Not a git repository (or any of the parent directories).')
+  }
+}
+
+function stripOuterQuotes(value) {
+  if (typeof value !== 'string') return value
+  const trimmed = value.trim()
+  const first = trimmed[0]
+  const last = trimmed[trimmed.length - 1]
+  if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+    return trimmed.slice(1, -1)
+  }
+  return trimmed
+}
+
+function parseEnvFile(envContent) {
+  const config = {}
+  envContent.split(/\r?\n/).forEach((line) => {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith('#')) return
+
+    const normalized = trimmed.startsWith('export ') ? trimmed.slice('export '.length) : trimmed
+    const idx = normalized.indexOf('=')
+    if (idx === -1) return
+
+    const key = normalized.slice(0, idx).trim()
+    const rawValue = normalized.slice(idx + 1).trim()
+    if (!key) return
+
+    config[key] = stripOuterQuotes(rawValue)
+  })
+  return config
+}
+
+function canonicalizeKey(key) {
+  return String(key || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, '')
+}
+
+function buildCanonicalKeyMap(knownKeys) {
+  const map = new Map()
+  for (const key of knownKeys) {
+    map.set(canonicalizeKey(key), key)
+  }
+  return map
+}
+
+function normalizeConfigKeys(rawConfig, knownKeys, keyMap) {
+  const config = rawConfig && typeof rawConfig === 'object' ? rawConfig : {}
+  const normalized = {}
+  for (const [rawKey, rawValue] of Object.entries(config)) {
+    if (knownKeys.has(rawKey)) {
+      normalized[rawKey] = rawValue
+      continue
+    }
+    const mapped = keyMap.get(canonicalizeKey(rawKey))
+    if (mapped) {
+      normalized[mapped] = rawValue
+      continue
+    }
+    normalized[rawKey] = rawValue
+  }
+  return normalized
+}
+
+function pickConfigFromProcessEnv(knownKeys, keyMap) {
+  const picked = {}
+  const prefixes = ['AI_REVIEW_', 'AI_CODE_REVIEW_KIT_']
+  for (const [rawKey, rawValue] of Object.entries(process.env || {})) {
+    if (rawValue == null || rawValue === '') continue
+
+    // Backward compatible: allow exact, case-sensitive config keys
+    if (knownKeys.has(rawKey)) {
+      picked[rawKey] = rawValue
+      continue
+    }
+
+    const prefix = prefixes.find((p) => rawKey.startsWith(p))
+    if (!prefix) continue
+
+    const suffix = rawKey.slice(prefix.length)
+    const mapped = keyMap.get(canonicalizeKey(suffix))
+    if (!mapped) continue
+    picked[mapped] = rawValue
+  }
+  return picked
+}
+
+function coerceConfigTypes(config) {
+  const next = { ...config }
+  const numberKeys = [
+    'maxChunkSize',
+    'temperature',
+    'diffContextLines',
+    'timeoutMs',
+    'concurrency',
+    'maxRetries',
+    'retryDelayMs',
+    'ragTopK',
+    'ragMaxChars',
+    'embeddingsDimensions',
+    'kbChunkSize',
+    'kbChunkOverlap',
+    'kbMaxFileSizeBytes',
+  ]
+  const booleanKeys = [
+    'strict',
+    'skipReview',
+    'showNormal',
+    'correctedResult',
+    'ignoreDeletions',
+    'stripUnchangedCommentLines',
+    'checkSecurity',
+    'checkPerformance',
+    'checkStyle',
+    'enableRag',
+    'useResponsesApi',
+  ]
+
+  for (const key of booleanKeys) {
+    if (typeof next[key] === 'string') {
+      const value = next[key].trim().toLowerCase()
+      if (value === 'true' || value === '1') next[key] = true
+      if (value === 'false' || value === '0') next[key] = false
+    }
+  }
+
+  for (const key of numberKeys) {
+    if (typeof next[key] === 'string' && next[key].trim() !== '') {
+      const num = Number(next[key])
+      if (!Number.isNaN(num)) next[key] = num
+    }
+  }
+  return next
+}
+
+function loadConfig(gitRoot) {
+  try {
+    const envPath = path.join(gitRoot, '.env')
+    const pkgPath = path.join(gitRoot, 'package.json')
+
+    let pkgConfig = {}
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+      if (pkg.aiCheckConfig && typeof pkg.aiCheckConfig === 'object') {
+        pkgConfig = pkg.aiCheckConfig
+      }
+    }
+
+    let envConfig = {}
+    if (fs.existsSync(envPath)) {
+      const envContent = fs.readFileSync(envPath, 'utf8')
+      envConfig = parseEnvFile(envContent)
+    }
+
+    const knownKeys = new Set([...Object.keys(defaultConfig), 'apiKey'])
+    const keyMap = buildCanonicalKeyMap(knownKeys)
+
+    pkgConfig = normalizeConfigKeys(pkgConfig, knownKeys, keyMap)
+    envConfig = normalizeConfigKeys(envConfig, knownKeys, keyMap)
+    const processEnvConfig = pickConfigFromProcessEnv(knownKeys, keyMap)
+
+    // Precedence: package.json < .env < process.env
+    const merged = coerceConfigTypes({ ...pkgConfig, ...envConfig, ...processEnvConfig })
+    if (Object.keys(merged).length === 0) {
+      throw new Error('No ai-code-review-kit configuration found in process.env, .env or package.json')
+    }
+    return merged
+  } catch (err) {
+    handleError('Configuration error:', err.message)
+  }
+}
+
+function getStagedChanges(fileExtensions, gitRoot) {
+  try {
+    const output = runGit(['diff', '--cached', '--name-only'], { cwd: gitRoot })
+    if (!output) {
+      console.log(chalk.yellow('No staged changes found.'))
+      process.exit(1)
+    }
+    const changedFiles = output.split('\n').filter(Boolean)
+    // 过滤指定扩展名的文件
+    const filteredFiles = changedFiles.filter(file => {
+      const ext = path.extname(file).toLowerCase()
+      return fileExtensions.includes(ext)
+    })
+
+    if (filteredFiles.length === 0) {
+      console.log(chalk.yellow(`No changes found in specified file types: ${fileExtensions.join(', ')}`))
+      process.exit(0)
+    }
+    return filteredFiles
+  } catch (err) {
+    handleError('Error checking staged changes:', err.message)
+  }
+}
+
+function getDiffContent(filteredFiles, config, gitRoot) {
+  try {
+    const diffArgs = ['diff', '--cached', '--no-color', `--unified=${config.diffContextLines}`]
+    if (filteredFiles.length) {
+      diffArgs.push('--', ...filteredFiles)
+    }
+    const diff = runGit(diffArgs, { cwd: gitRoot })
+    
+    if (!diff) {
+      console.log(chalk.yellow('No diff content found for files:'), filteredFiles.join(', '));
+      process.exit(0);
+    }
+    return diff;
+  } catch (err) {
+    handleError('Error getting diff:', err.message);
+  }
+}
+
+function handleError (text, message) {
+  console.error(chalk.red(text), message)
+  process.exit(1)
+}
+
+function summarizeIssues(list) {
+  const counts = { high: 0, medium: 0, low: 0 }
+  const items = Array.isArray(list) ? list : []
+  for (const item of items) {
+    if (item?.severity === 'high') counts.high += 1
+    else if (item?.severity === 'medium') counts.medium += 1
+    else if (item?.severity === 'low') counts.low += 1
+  }
+  return counts
+}
+
+function handleReviewResult(result, completeConfig) {
+  let exitCode = 0
+  if(result.result === 'NO') {
+    console.log(chalk.redBright('X Code review was not passed.Please fix the following high-level issues and try again.'))
+    exitCode = 1
+  } else {
+    console.log(chalk.green('√ Code review passed.'))
+    exitCode = 0 
+  } 
+
+  const counts = summarizeIssues(result.list)
+  const sessions = result?.meta?.sessions
+  const durationMs = result?.meta?.durationMs
+  const providerType = result?.meta?.providerType || completeConfig.providerType
+  const model = result?.meta?.model || completeConfig.model
+  const baseURL = result?.meta?.baseURL || completeConfig.baseURL
+  const ragEnabled = Boolean(result?.meta?.ragEnabled)
+  const ragUsed = Boolean(result?.meta?.ragUsed)
+
+  console.log(
+    chalk.gray(
+      `Summary: sessions=${sessions ?? 'n/a'}, issues(high/medium/low)=${counts.high}/${counts.medium}/${counts.low}, errors=${result.errors?.length || 0}, duration=${Number.isFinite(durationMs) ? `${durationMs}ms` : 'n/a'}`
+    )
+  )
+  console.log(
+    chalk.gray(
+      `Provider: ${String(providerType || '').toUpperCase()}${model ? ` model=${model}` : ''}${baseURL ? ` baseURL=${baseURL}` : ''} | RAG: ${ragEnabled ? (ragUsed ? 'used' : 'enabled (no hits)') : 'off'}`
+    )
+  )
+
+  const printList =  result.list.filter(issue => {
+    if(issue.severity === 'high') {
+      return true
+    }
+    return completeConfig.showNormal
+  })
+  if(printList.length) {
+    console.log('\n' + chalk.gray('-'.repeat(50)) + '\n');
+    printList.forEach(issue => {
+      const color = issue.severity === 'high' ? chalk.red : issue.severity === 'medium' ? chalk.yellow : chalk.green
+      console.log(color(`- ${issue.location}(${issue.perspective}/${issue.severity}): ${issue.description}\n`) + chalk.blue(`- suggestion: ${issue.suggestion}\n`))
+      
+    })
+    if(result.errors.length) {
+      console.log(chalk.redBright('some content failed to be reviewed, please check the error message above.'))
+      result.errors.forEach(error => {
+        console.log(chalk.redBright(error)) 
+      })
+    }
+  } else if(result.errors.length) {
+    console.log(chalk.redBright(result.errors[0]))
+  }
+  process.exit(exitCode)
+}
+
+function getFileExtensions(config) {
+  try {
+    const extensions = config.enabledFileExtensions.split(',').map(ext => ext.trim().toLowerCase())
+    return extensions 
+  } catch (err) {
+    handleError('Error getting file extensions:', err.message)
+  }
+}
+export async function main(argv = process.argv.slice(2)) {
+  if (argv.includes('--help') || argv.includes('-h')) {
+    console.log(`Usage: ai-review run\n\nRuns AI code review for staged git changes.`)
+    process.exit(0)
+  }
+  const gitRoot = getGitRoot()
+  const config = loadConfig(gitRoot)
+  const completeConfig = Object.assign({}, defaultConfig, config, { repoRoot: gitRoot });
+  if (completeConfig.skipReview) {
+    console.log(chalk.yellow('AI review skipped (skipReview=true).'))
+    process.exit(0)
+  }
+  const fileExtensions = getFileExtensions(completeConfig)
+  const changesFiles = getStagedChanges(fileExtensions, gitRoot)
+  console.log(`Find ${chalk.cyan(changesFiles.length)} changed files...`)
+  const diffConent = getDiffContent(changesFiles, completeConfig, gitRoot)
+  try {
+    const reviewer = new CodeReviewer(completeConfig)
+    const result = await reviewer.review(diffConent, fileExtensions)
+    handleReviewResult(result, completeConfig)
+  } catch (err) {
+    if(err instanceof AIError && err.options.type === 'API_ERROR' && !completeConfig.strict) { 
+      console.log(chalk.red('Code review failed.Please check your AI server and try again.'))
+      console.log(chalk.red('Error message:'), err.message)
+      process.exit(0)
+    }
+    handleError('Code review error:', err.message)
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+if (isMain) {
+  main()
+}

package/src/cli.js

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+
+import { execFileSync } from 'child_process'
+import chalk from 'chalk'
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+function parseArgs(argv) {
+  const args = {
+    target: 'git', // auto | git | husky
+    check: false,
+    uninstall: false,
+    force: false,
+  }
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    if (arg === '--check' || arg === '-c') args.check = true
+    else if (arg === '--uninstall' || arg === '--remove') args.uninstall = true
+    else if (arg === '--force' || arg === '-f') args.force = true
+    else if (arg === '--target' || arg === '-t') {
+      const value = argv[i + 1]
+      if (value) {
+        args.target = String(value).toLowerCase()
+        i += 1
+      }
+    } else if (arg.startsWith('--target=')) {
+      args.target = String(arg.split('=')[1] || '').toLowerCase()
+    }
+  }
+
+  if (!['auto', 'git', 'husky'].includes(args.target)) {
+    console.error(chalk.red(`Invalid --target: ${args.target}. Use auto|git|husky.`))
+    process.exit(1)
+  }
+  return args
+}
+
+function shEscape(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`
+}
+
+function runGit(args, options = {}) {
+  return execFileSync('git', args, { encoding: 'utf8', ...options }).trim()
+}
+
+function getGitRoot() {
+  try {
+    return runGit(['rev-parse', '--show-toplevel'], { cwd: process.cwd() })
+  } catch {
+    console.error(chalk.red('Not a git repository (or any of the parent directories).'))
+    process.exit(1)
+  }
+}
+
+function resolveGitPath(gitRoot, gitPath) {
+  return path.isAbsolute(gitPath) ? gitPath : path.join(gitRoot, gitPath)
+}
+
+function getGitHooksPath(gitRoot) {
+  const hooksPath = runGit(['rev-parse', '--git-path', 'hooks'], { cwd: gitRoot })
+  return resolveGitPath(gitRoot, hooksPath)
+}
+
+function getTargetForInstall(gitRoot, target) {
+  if (target === 'git') return 'git'
+  if (target === 'husky') return 'husky'
+
+  // auto
+  const huskyDir = path.join(gitRoot, '.husky')
+  if (fs.existsSync(huskyDir) && fs.statSync(huskyDir).isDirectory()) {
+    return 'husky'
+  }
+  return 'git'
+}
+
+function removeHookBlock(content, markerStart, markerEnd) {
+  let output = content
+  while (true) {
+    const startIdx = output.indexOf(markerStart)
+    if (startIdx === -1) return output
+
+    const endIdx = output.indexOf(markerEnd, startIdx)
+    if (endIdx !== -1) {
+      const afterEnd = output.indexOf('\n', endIdx)
+      output = output.slice(0, startIdx).trimEnd() + '\n' + output.slice(afterEnd === -1 ? output.length : afterEnd + 1)
+    } else {
+      // Backward compatible uninstall: older versions only had a start marker.
+      output = output.slice(0, startIdx).trimEnd() + '\n'
+    }
+  }
+}
+
+function hasMarker(filePath, markerStart) {
+  if (!fs.existsSync(filePath)) return false
+  const content = fs.readFileSync(filePath, 'utf8')
+  return content.includes(markerStart)
+}
+
+function writeExecutable(filePath, content) {
+  fs.writeFileSync(filePath, content, 'utf8')
+  fs.chmodSync(filePath, '755')
+}
+
+function getInstallPaths(gitRoot) {
+  const huskyPreCommitPath = path.join(gitRoot, '.husky', 'pre-commit')
+  const gitHooksPath = getGitHooksPath(gitRoot)
+  const gitPreCommitPath = path.join(gitHooksPath, 'pre-commit')
+  return { huskyPreCommitPath, gitHooksPath, gitPreCommitPath }
+}
+
+function buildHookBlock({ gitRoot, nodePath, aiReviewPath, markerStart, markerEnd }) {
+  // Prefer repo-local install for portability; fallback to current absolute path.
+  const repoBin = '"$git_root/node_modules/.bin/ai-review"'
+  const repoMain = '"$git_root/node_modules/ai-code-review-kit/src/ai-review.js"'
+  const pnpCjs = '"$git_root/.pnp.cjs"'
+  return `${markerStart}
+run_node() {
+  if command -v node >/dev/null 2>&1; then
+    node "$@"
+  else
+    ${shEscape(nodePath)} "$@"
+  fi
+}
+
+git_root="$(git rev-parse --show-toplevel 2>/dev/null)"
+if [ -n "$git_root" ]; then
+  # Yarn PnP (no node_modules). Prefer running via yarn.
+  if [ -f ${pnpCjs} ]; then
+    if command -v yarn >/dev/null 2>&1; then
+      yarn -s ai-review run
+      exit $?
+    elif command -v corepack >/dev/null 2>&1; then
+      corepack yarn -s ai-review run
+      exit $?
+    fi
+  fi
+
+  # npm/yarn (node_modules)
+  if [ -f ${repoMain} ]; then
+    run_node ${repoMain}
+    exit $?
+  fi
+  if [ -f ${repoBin} ]; then
+    ${repoBin} run
+    exit $?
+  fi
+fi
+
+run_node ${shEscape(aiReviewPath)}
+${markerEnd}
+`
+}
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true })
+  }
+}
+
+function installToGitHooks({ gitRoot, gitHooksPath, preCommitPath, hookBlock, markerStart, markerEnd, force }) {
+  ensureDir(gitHooksPath)
+  if (fs.existsSync(preCommitPath)) {
+    const hookContent = fs.readFileSync(preCommitPath, 'utf8')
+    if (hookContent.includes(markerStart)) {
+      if (!force) {
+        console.log(chalk.yellow('Hook already exists.'))
+        return
+      }
+      const cleaned = removeHookBlock(hookContent, markerStart, markerEnd)
+      const next = `${cleaned.trimEnd()}\n\n${hookBlock}`
+      writeExecutable(preCommitPath, next)
+      console.log(chalk.green('Hook reinstalled successfully.'))
+      return
+    }
+    const newHookContent = `${hookContent.trimEnd()}\n\n${hookBlock}`
+    writeExecutable(preCommitPath, newHookContent)
+  } else {
+    const hookContent = `#!/bin/sh\n${hookBlock}`
+    writeExecutable(preCommitPath, hookContent)
+  }
+  console.log(chalk.green('Hook installed successfully.'))
+}
+
+function installToHusky({ gitRoot, huskyPreCommitPath, hookBlock, markerStart, markerEnd, force }) {
+  const huskyDir = path.join(gitRoot, '.husky')
+  if (!fs.existsSync(huskyDir) || !fs.statSync(huskyDir).isDirectory()) {
+    console.error(chalk.red('Husky directory not found. Please install husky first or use --target git.'))
+    process.exit(1)
+  }
+
+  const huskyShim = path.join(huskyDir, '_', 'husky.sh')
+  const header = fs.existsSync(huskyShim)
+    ? `#!/bin/sh\n. "$(dirname \"$0\")/_/husky.sh"\n`
+    : `#!/bin/sh\n`
+
+  if (fs.existsSync(huskyPreCommitPath)) {
+    const hookContent = fs.readFileSync(huskyPreCommitPath, 'utf8')
+    if (hookContent.includes(markerStart)) {
+      if (!force) {
+        console.log(chalk.yellow('Hook already exists.'))
+        return
+      }
+      const cleaned = removeHookBlock(hookContent, markerStart, markerEnd)
+      const next = `${cleaned.trimEnd()}\n\n${hookBlock}`
+      writeExecutable(huskyPreCommitPath, next)
+      console.log(chalk.green('Hook reinstalled successfully.'))
+      return
+    }
+    const next = `${hookContent.trimEnd()}\n\n${hookBlock}`
+    writeExecutable(huskyPreCommitPath, next)
+  } else {
+    const hookContent = `${header}${hookBlock}`
+    writeExecutable(huskyPreCommitPath, hookContent)
+  }
+  console.log(chalk.green('Hook installed successfully.'))
+}
+
+function uninstallFromFile(filePath, markerStart, markerEnd) {
+  if (!fs.existsSync(filePath)) return false
+  const content = fs.readFileSync(filePath, 'utf8')
+  if (!content.includes(markerStart)) return false
+  const cleaned = removeHookBlock(content, markerStart, markerEnd)
+  writeExecutable(filePath, cleaned.trimEnd() + '\n')
+  return true
+}
+
+export function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv)
+
+  const gitRoot = getGitRoot()
+  const { huskyPreCommitPath, gitHooksPath, gitPreCommitPath } = getInstallPaths(gitRoot)
+
+  const aiReviewPath = fileURLToPath(new URL('./ai-review.js', import.meta.url))
+  const nodePath = process.execPath
+  const markerStart = '# ai-code-review-kit'
+  const markerEnd = '# /ai-code-review-kit'
+  const hookBlock = buildHookBlock({ gitRoot, nodePath, aiReviewPath, markerStart, markerEnd })
+
+  if (args.check) {
+    const targets = args.target === 'auto' ? ['husky', 'git'] : [args.target]
+    const checks = targets.map((t) => {
+      const filePath = t === 'husky' ? huskyPreCommitPath : gitPreCommitPath
+      return { target: t, installed: hasMarker(filePath, markerStart), filePath }
+    })
+    const anyInstalled = checks.some((c) => c.installed)
+    checks.forEach((c) => {
+      const status = c.installed ? chalk.green('installed') : chalk.gray('not installed')
+      console.log(`${chalk.cyan(c.target)}: ${status} (${c.filePath})`)
+    })
+    process.exit(anyInstalled ? 0 : 1)
+  }
+
+  if (args.uninstall) {
+    const order = args.target === 'auto' ? ['husky', 'git'] : [args.target]
+    let removed = false
+    for (const t of order) {
+      const filePath = t === 'husky' ? huskyPreCommitPath : gitPreCommitPath
+      if (uninstallFromFile(filePath, markerStart, markerEnd)) {
+        console.log(chalk.green(`Hook removed from ${t}: ${filePath}`))
+        removed = true
+      }
+    }
+    if (!removed) {
+      console.log(chalk.yellow('Hook not found.'))
+    }
+    process.exit(0)
+  }
+
+  const target = getTargetForInstall(gitRoot, args.target)
+  if (target === 'husky') {
+    installToHusky({ gitRoot, huskyPreCommitPath, hookBlock, markerStart, markerEnd, force: args.force })
+  } else {
+    installToGitHooks({ gitRoot, gitHooksPath, preCommitPath: gitPreCommitPath, hookBlock, markerStart, markerEnd, force: args.force })
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+if (isMain) {
+  main()
+}