create-fullstack-scaffold 0.1.0

package/template/lint-scripts/test-tracker.ts

@@ -0,0 +1,350 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process'
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const PROJECT_ROOT = join(__dirname, '..')
+const HISTORY_DIR = join(PROJECT_ROOT, '.test-history')
+const RUNS_DIR = join(HISTORY_DIR, 'runs')
+
+export interface TestCaseResult {
+  name: string
+  file: string
+  status: 'passed' | 'failed' | 'skipped'
+  duration: number
+  error?: string
+}
+
+export interface TestRunRecord {
+  timestamp: string
+  commitSha: string
+  shortSha: string
+  commitMessage: string
+  author: string
+  branch: string
+  totalTests: number
+  passed: number
+  failed: number
+  skipped: number
+  duration: number
+  testResults: TestCaseResult[]
+  environment: {
+    nodeVersion: string
+    platform: string
+  }
+}
+
+export interface TestHistoryIndex {
+  lastUpdated: string
+  totalRuns: number
+  runs: Array<{
+    timestamp: string
+    commitSha: string
+    shortSha: string
+    commitMessage: string
+    branch: string
+    passed: number
+    failed: number
+    total: number
+  }>
+}
+
+export interface VitestTestResult {
+  name: string
+  moduleName?: string
+  status: 'passed' | 'failed' | 'skipped' | 'todo'
+  duration: number
+  errors?: Array<{ message: string }>
+}
+
+export interface VitestSuiteResult {
+  name: string
+  file?: string
+  tests: VitestTestResult[]
+  suites?: VitestSuiteResult[]
+}
+
+export interface VitestJsonReport {
+  testResults: Array<{
+    name: string
+    assertionResults: Array<{
+      ancestorTitles: string[]
+      fullName: string
+      status: 'passed' | 'failed' | 'skipped' | 'todo'
+      duration: number
+      failureMessages: string[]
+    }>
+    status: 'passed' | 'failed' | 'skipped'
+  }>
+  success: boolean
+  numTotalTests: number
+  numPassedTests: number
+  numFailedTests: number
+  numPendingTests: number
+  startTime: number
+}
+
+export function getGitInfo(): {
+  commitSha: string
+  shortSha: string
+  commitMessage: string
+  author: string
+  branch: string
+} {
+  try {
+    const commitSha = execSync('git rev-parse HEAD', { encoding: 'utf-8' }).trim()
+    const shortSha = execSync('git rev-parse --short HEAD', { encoding: 'utf-8' }).trim()
+    const commitMessage = execSync('git log -1 --pretty=%B', { encoding: 'utf-8' }).trim()
+    const author = execSync('git log -1 --pretty=%an', { encoding: 'utf-8' }).trim()
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim()
+
+    return { commitSha, shortSha, commitMessage, author, branch }
+  } catch (error) {
+    console.error('Failed to get git info:', error)
+    return {
+      commitSha: 'unknown',
+      shortSha: 'unknown',
+      commitMessage: 'unknown',
+      author: 'unknown',
+      branch: 'unknown',
+    }
+  }
+}
+
+export function ensureDirectories(): void {
+  if (!existsSync(HISTORY_DIR)) {
+    mkdirSync(HISTORY_DIR, { recursive: true })
+  }
+  if (!existsSync(RUNS_DIR)) {
+    mkdirSync(RUNS_DIR, { recursive: true })
+  }
+}
+
+export function runTestsWithJson(): VitestJsonReport | null {
+  try {
+    const output = execSync('npx vitest run --reporter=json --reporter=default', {
+      encoding: 'utf-8',
+      cwd: PROJECT_ROOT,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    const lines = output.split('\n')
+    let jsonOutput = ''
+
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line)
+        if (parsed.testResults) {
+          jsonOutput = line
+          break
+        }
+      } catch {
+        continue
+      }
+    }
+
+    if (jsonOutput) {
+      return JSON.parse(jsonOutput)
+    }
+
+    return null
+  } catch (error) {
+    const err = error as { stdout?: string }
+    if (err.stdout) {
+      const lines = err.stdout.split('\n')
+      for (const line of lines) {
+        try {
+          const parsed = JSON.parse(line)
+          if (parsed.testResults) {
+            return parsed
+          }
+        } catch {
+          continue
+        }
+      }
+    }
+    return null
+  }
+}
+
+export function parseTestResults(report: VitestJsonReport): TestCaseResult[] {
+  const results: TestCaseResult[] = []
+
+  for (const testFile of report.testResults) {
+    for (const assertion of testFile.assertionResults) {
+      results.push({
+        name: assertion.fullName,
+        file: testFile.name,
+        status: assertion.status === 'todo' ? 'skipped' : assertion.status,
+        duration: assertion.duration || 0,
+        error:
+          assertion.failureMessages && assertion.failureMessages.length > 0
+            ? assertion.failureMessages.join('\n')
+            : undefined,
+      })
+    }
+  }
+
+  return results
+}
+
+export function createTestRecord(
+  report: VitestJsonReport,
+  gitInfo: ReturnType<typeof getGitInfo>
+): TestRunRecord {
+  const testResults = parseTestResults(report)
+
+  return {
+    timestamp: new Date().toISOString(),
+    commitSha: gitInfo.commitSha,
+    shortSha: gitInfo.shortSha,
+    commitMessage: gitInfo.commitMessage,
+    author: gitInfo.author,
+    branch: gitInfo.branch,
+    totalTests: report.numTotalTests,
+    passed: report.numPassedTests,
+    failed: report.numFailedTests,
+    skipped: report.numPendingTests,
+    duration: Date.now() - report.startTime,
+    testResults,
+    environment: {
+      nodeVersion: process.version,
+      platform: process.platform,
+    },
+  }
+}
+
+export function saveTestRecord(record: TestRunRecord): void {
+  ensureDirectories()
+
+  const runFile = join(RUNS_DIR, `${record.shortSha}.json`)
+  writeFileSync(runFile, JSON.stringify(record, null, 2), 'utf-8')
+
+  const latestFile = join(HISTORY_DIR, 'latest.json')
+  writeFileSync(latestFile, JSON.stringify(record, null, 2), 'utf-8')
+
+  updateIndex(record)
+
+  console.log(`📊 Results saved to .test-history/runs/${record.shortSha}.json`)
+}
+
+export function updateIndex(record: TestRunRecord): void {
+  const indexFile = join(HISTORY_DIR, 'index.json')
+  let index: TestHistoryIndex
+
+  if (existsSync(indexFile)) {
+    try {
+      index = JSON.parse(readFileSync(indexFile, 'utf-8'))
+    } catch {
+      index = { lastUpdated: '', totalRuns: 0, runs: [] }
+    }
+  } else {
+    index = { lastUpdated: '', totalRuns: 0, runs: [] }
+  }
+
+  const existingIndex = index.runs.findIndex(r => r.commitSha === record.commitSha)
+  const runEntry = {
+    timestamp: record.timestamp,
+    commitSha: record.commitSha,
+    shortSha: record.shortSha,
+    commitMessage: record.commitMessage,
+    branch: record.branch,
+    passed: record.passed,
+    failed: record.failed,
+    total: record.totalTests,
+  }
+
+  if (existingIndex >= 0) {
+    index.runs[existingIndex] = runEntry
+  } else {
+    index.runs.unshift(runEntry)
+  }
+
+  index.lastUpdated = new Date().toISOString()
+  index.totalRuns = index.runs.length
+
+  writeFileSync(indexFile, JSON.stringify(index, null, 2), 'utf-8')
+}
+
+export function loadIndex(): TestHistoryIndex | null {
+  const indexFile = join(HISTORY_DIR, 'index.json')
+  if (!existsSync(indexFile)) {
+    return null
+  }
+  try {
+    return JSON.parse(readFileSync(indexFile, 'utf-8'))
+  } catch {
+    return null
+  }
+}
+
+export function loadRunRecord(shortSha: string): TestRunRecord | null {
+  const runFile = join(RUNS_DIR, `${shortSha}.json`)
+  if (!existsSync(runFile)) {
+    return null
+  }
+  try {
+    return JSON.parse(readFileSync(runFile, 'utf-8'))
+  } catch {
+    return null
+  }
+}
+
+export function loadLatestRecord(): TestRunRecord | null {
+  const latestFile = join(HISTORY_DIR, 'latest.json')
+  if (!existsSync(latestFile)) {
+    return null
+  }
+  try {
+    return JSON.parse(readFileSync(latestFile, 'utf-8'))
+  } catch {
+    return null
+  }
+}
+
+export function trackTests(): void {
+  if (process.env.SKIP_TEST_TRACK === 'true') {
+    console.log('⏭️  Test tracking skipped (SKIP_TEST_TRACK=true)')
+    process.exit(0)
+  }
+
+  console.log('📝 Tracking test results for this commit...')
+
+  const gitInfo = getGitInfo()
+  console.log(`🔍 Commit: ${gitInfo.shortSha} - ${gitInfo.commitMessage}`)
+
+  console.log('🧪 Running tests...')
+  const report = runTestsWithJson()
+
+  if (!report) {
+    console.error('❌ Failed to get test results')
+    process.exit(1)
+  }
+
+  const record = createTestRecord(report, gitInfo)
+  saveTestRecord(record)
+
+  const status = record.failed === 0 ? '✅' : '❌'
+  console.log(
+    `\n${status} Tests: ${record.passed}/${record.totalTests} passed, ${record.failed} failed`
+  )
+  console.log(`⏱️  Duration: ${(record.duration / 1000).toFixed(2)}s`)
+
+  if (record.failed > 0) {
+    console.log('\n❌ Failed tests:')
+    for (const test of record.testResults.filter(t => t.status === 'failed')) {
+      console.log(`  - ${test.name}`)
+      if (test.error) {
+        console.log(`    ${test.error.split('\n')[0]}`)
+      }
+    }
+  }
+}
+
+if (process.argv[1] === __filename) {
+  trackTests()
+}

package/template/lint-scripts/validate-all.ts

@@ -0,0 +1,250 @@
+#!/usr/bin/env tsx
+/**
+ * 统一验证入口
+ *
+ * 运行所有验证器
+ * 可以选择性运行特定验证器
+ */
+
+import { cwd } from 'node:process'
+import { validateTodos, formatTodoErrors } from './validators/todos.validator.js'
+import { validateSensitive, formatSensitiveErrors } from './validators/sensitive.validator.js'
+import { validateImports, formatImportErrors } from './validators/imports.validator.js'
+import { validateServerRPC, formatServerRPCErrors } from './validators/server-rpc.validator.js'
+import { validateClientRPC, formatClientRPCErrors } from './validators/client-rpc.validator.js'
+import {
+  validateDirectoryStructure,
+  formatDirectoryErrors,
+} from './validators/directory-structure.validator.js'
+import { validateModuleTests, formatModuleTestErrors } from './validators/module-tests.validator.js'
+import {
+  validateTestQuality,
+  formatTestQualityErrors,
+} from './validators/test-quality.validator.js'
+import { validateClientTests, formatClientTestErrors } from './validators/client-tests.validator.js'
+import { validateMdRefs, formatMdRefErrors } from './validators/md-refs.validator.js'
+import {
+  validateAPICoverage,
+  formatAPICoverageErrors,
+} from './validators/api-coverage.validator.js'
+import { validateConsoleLog, formatConsoleLogErrors } from './validators/console-log.validator.js'
+import projectConfig from './config/project.config.js'
+
+interface ValidatorResult {
+  name: string
+  passed: boolean
+  errors: number
+}
+
+async function runAllValidators(): Promise<ValidatorResult[]> {
+  const rootPath = cwd()
+  const results: ValidatorResult[] = []
+
+  // 1. TODO 验证
+  console.log('🔍 [1/12] Checking TODO/FIXME comments...')
+  const todoErrors = validateTodos(projectConfig.todos, rootPath)
+  results.push({
+    name: 'TODO/FIXME',
+    passed: todoErrors.length === 0,
+    errors: todoErrors.length,
+  })
+  if (todoErrors.length > 0) {
+    console.error(formatTodoErrors(todoErrors))
+  } else {
+    console.log('  ✅ No unassigned TODOs found\n')
+  }
+
+  // 2. 敏感信息验证
+  console.log('🔍 [2/12] Checking for sensitive data...')
+  const sensitiveErrors = await validateSensitive(projectConfig.sensitive, rootPath)
+  results.push({
+    name: 'Sensitive Data',
+    passed: sensitiveErrors.length === 0,
+    errors: sensitiveErrors.length,
+  })
+  if (sensitiveErrors.length > 0) {
+    console.error(formatSensitiveErrors(sensitiveErrors))
+  } else {
+    console.log('  ✅ No sensitive data found\n')
+  }
+
+  // 3. 导入路径验证
+  console.log('🔍 [3/12] Checking import paths...')
+  const importErrors = validateImports(projectConfig.imports, rootPath)
+  results.push({
+    name: 'Import Paths',
+    passed: importErrors.length === 0,
+    errors: importErrors.length,
+  })
+  if (importErrors.length > 0) {
+    console.error(formatImportErrors(importErrors))
+  } else {
+    console.log('  ✅ All imports are valid\n')
+  }
+
+  // 4. 服务端 RPC 验证
+  console.log('🔍 [4/12] Checking server RPC patterns...')
+  const serverRPCErrors = validateServerRPC(projectConfig.serverRPC, rootPath)
+  results.push({
+    name: 'Server RPC',
+    passed: serverRPCErrors.length === 0,
+    errors: serverRPCErrors.length,
+  })
+  if (serverRPCErrors.length > 0) {
+    console.error(formatServerRPCErrors(serverRPCErrors))
+  } else {
+    console.log('  ✅ Server RPC patterns are valid\n')
+  }
+
+  // 5. 客户端 RPC 验证
+  console.log('🔍 [5/12] Checking client RPC usage...')
+  const clientRPCErrors = validateClientRPC(projectConfig.clientRPC, rootPath)
+  results.push({
+    name: 'Client RPC',
+    passed: clientRPCErrors.length === 0,
+    errors: clientRPCErrors.length,
+  })
+  if (clientRPCErrors.length > 0) {
+    console.error(formatClientRPCErrors(clientRPCErrors))
+  } else {
+    console.log('  ✅ Client RPC usage is valid\n')
+  }
+
+  // 6. 目录结构验证
+  console.log('🔍 [6/12] Checking directory structure...')
+  const { directoryErrors, forbiddenErrors } = validateDirectoryStructure(
+    projectConfig.directory,
+    rootPath
+  )
+  const totalDirectoryErrors = directoryErrors.length + forbiddenErrors.length
+  results.push({
+    name: 'Directory Structure',
+    passed: totalDirectoryErrors === 0,
+    errors: totalDirectoryErrors,
+  })
+  if (totalDirectoryErrors > 0) {
+    console.error(formatDirectoryErrors(directoryErrors, forbiddenErrors))
+  } else {
+    console.log('  ✅ Directory structure is valid\n')
+  }
+
+  // 7. 模块测试文件验证
+  console.log('🔍 [7/12] Checking module test files...')
+  const moduleTestErrors = validateModuleTests(projectConfig.moduleTests, rootPath)
+  results.push({
+    name: 'Module Tests',
+    passed: moduleTestErrors.length === 0,
+    errors: moduleTestErrors.length,
+  })
+  if (moduleTestErrors.length > 0) {
+    console.error(formatModuleTestErrors(moduleTestErrors))
+  } else {
+    console.log('  ✅ All modules have required test files\n')
+  }
+
+  // 8. 测试质量验证
+  console.log('🔍 [8/12] Checking test quality...')
+  const { errors: testQualityErrors, warnings: testQualityWarnings } = validateTestQuality(
+    projectConfig.testQuality,
+    rootPath
+  )
+  const totalTestQualityIssues = testQualityErrors.length + testQualityWarnings.length
+  results.push({
+    name: 'Test Quality',
+    passed: testQualityErrors.length === 0,
+    errors: testQualityErrors.length,
+  })
+  if (totalTestQualityIssues > 0) {
+    console.error(formatTestQualityErrors(testQualityErrors, testQualityWarnings))
+  } else {
+    console.log('  ✅ Test quality is good\n')
+  }
+
+  // 9. Client 测试覆盖验证
+  console.log('🔍 [9/12] Checking client test coverage...')
+  const clientTestErrors = validateClientTests(projectConfig.clientTests, rootPath)
+  results.push({
+    name: 'Client Tests',
+    passed: clientTestErrors.length === 0,
+    errors: clientTestErrors.length,
+  })
+  if (clientTestErrors.length > 0) {
+    console.error(formatClientTestErrors(clientTestErrors))
+  } else {
+    console.log('  ✅ All client files have tests\n')
+  }
+
+  // 10. API 覆盖率验证
+  console.log('🔍 [10/12] Checking API coverage...')
+  const apiCoverageErrors = validateAPICoverage(projectConfig.moduleTests, rootPath)
+  results.push({
+    name: 'API Coverage',
+    passed: apiCoverageErrors.length === 0,
+    errors: apiCoverageErrors.length,
+  })
+  if (apiCoverageErrors.length > 0) {
+    console.error(formatAPICoverageErrors(apiCoverageErrors))
+  } else {
+    console.log('  ✅ All APIs are covered by tests\n')
+  }
+
+  // 11. Markdown 引用路径验证
+  console.log('🔍 [11/12] Checking markdown references...')
+  const mdRefErrors = validateMdRefs(projectConfig.mdRefs, rootPath)
+  results.push({
+    name: 'Markdown References',
+    passed: mdRefErrors.length === 0,
+    errors: mdRefErrors.length,
+  })
+  if (mdRefErrors.length > 0) {
+    console.error(formatMdRefErrors(mdRefErrors))
+  } else {
+    console.log('  ✅ All markdown references are valid\n')
+  }
+
+  // 12. Console.log 验证
+  console.log('🔍 [12/12] Checking for console.log statements...')
+  const consoleLogErrors = validateConsoleLog(projectConfig.consoleLog, rootPath)
+  results.push({
+    name: 'Console.log',
+    passed: consoleLogErrors.length === 0,
+    errors: consoleLogErrors.length,
+  })
+  if (consoleLogErrors.length > 0) {
+    console.error(formatConsoleLogErrors(consoleLogErrors))
+  } else {
+    console.log('  ✅ No console.log statements found\n')
+  }
+
+  return results
+}
+
+async function main() {
+  console.log('🚀 Running all validators...\n')
+
+  const results = await runAllValidators()
+
+  // 汇总结果
+  const failed = results.filter(r => !r.passed)
+  const totalErrors = results.reduce((sum, r) => sum + r.errors, 0)
+
+  console.log('\n' + '='.repeat(50))
+  console.log('📊 Validation Summary:')
+  console.log('='.repeat(50))
+
+  for (const result of results) {
+    const status = result.passed ? '✅' : '❌'
+    console.log(`  ${status} ${result.name}: ${result.errors} error(s)`)
+  }
+
+  console.log('='.repeat(50))
+
+  if (failed.length > 0) {
+    console.error(`\n❌ Validation failed with ${totalErrors} total error(s)`)
+    process.exit(1)
+  }
+
+  console.log('\n✅ All validations passed!')
+}
+
+main()