create-fullstack-scaffold 0.1.0

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

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process'
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs'
+import { resolve, relative, dirname, basename, join } from 'path'
+
+interface TestFile {
+  path: string
+  dependencies: Set<string>
+}
+
+interface ChangedFiles {
+  added: string[]
+  modified: string[]
+  deleted: string[]
+}
+
+const PROJECT_ROOT = process.cwd()
+
+function findTestFiles(): string[] {
+  const testFiles: string[] = []
+
+  function scanDir(dir: string) {
+    try {
+      const items = readdirSync(dir)
+
+      for (const item of items) {
+        const fullPath = join(dir, item)
+
+        if (item === 'node_modules' || item === 'dist' || item === '.git') continue
+
+        try {
+          const stat = statSync(fullPath)
+
+          if (stat.isDirectory()) {
+            scanDir(fullPath)
+          } else if (stat.isFile()) {
+            if (item.includes('.test.') || item.includes('.spec.')) {
+              if (item.endsWith('.ts') || item.endsWith('.tsx')) {
+                testFiles.push(relative(PROJECT_ROOT, fullPath))
+              }
+            }
+          }
+        } catch (error) {}
+      }
+    } catch (error) {}
+  }
+
+  scanDir(PROJECT_ROOT)
+  return testFiles
+}
+
+function getChangedFiles(): ChangedFiles {
+  try {
+    const isStaged = process.argv.includes('--staged')
+
+    let diffCommand: string
+    if (isStaged) {
+      diffCommand = 'git diff --cached --name-status'
+    } else {
+      diffCommand = 'git diff HEAD --name-status'
+    }
+
+    const output = execSync(diffCommand, { encoding: 'utf-8' })
+    const lines = output.trim().split('\n').filter(Boolean)
+
+    const changed: ChangedFiles = {
+      added: [],
+      modified: [],
+      deleted: [],
+    }
+
+    for (const line of lines) {
+      const [status, ...paths] = line.split(/\s+/)
+      const filePath = paths[0]
+
+      if (!filePath) continue
+
+      switch (status) {
+        case 'A':
+          changed.added.push(filePath)
+          break
+        case 'M':
+        case 'R':
+          changed.modified.push(filePath)
+          break
+        case 'D':
+          changed.deleted.push(filePath)
+          break
+      }
+    }
+
+    return changed
+  } catch (error) {
+    console.log('No changes detected or not in a git repository')
+    return { added: [], modified: [], deleted: [] }
+  }
+}
+
+function extractImports(filePath: string): string[] {
+  try {
+    if (!existsSync(filePath)) return []
+
+    const content = readFileSync(filePath, 'utf-8')
+    const imports: string[] = []
+
+    const importRegex = /import\s+.*?from\s+['"]([^'"]+)['"]/g
+    let match
+
+    while ((match = importRegex.exec(content)) !== null) {
+      const importPath = match[1]
+
+      if (importPath.startsWith('.')) {
+        const resolvedPath = resolve(dirname(filePath), importPath)
+        imports.push(resolvedPath)
+      } else if (
+        importPath.startsWith('@shared/') ||
+        importPath.startsWith('@client/') ||
+        importPath.startsWith('@server/')
+      ) {
+        const aliasPath = importPath
+          .replace('@shared/', 'src/shared/')
+          .replace('@client/', 'src/client/')
+          .replace('@server/', 'src/server/')
+        imports.push(resolve(PROJECT_ROOT, aliasPath))
+      }
+    }
+
+    return imports
+  } catch (error) {
+    return []
+  }
+}
+
+function buildDependencyGraph(testFiles: string[]): Map<string, Set<string>> {
+  const graph = new Map<string, Set<string>>()
+
+  function getDependencies(filePath: string, visited: Set<string>): Set<string> {
+    if (visited.has(filePath)) return new Set()
+    visited.add(filePath)
+
+    const deps = new Set<string>()
+    const imports = extractImports(filePath)
+
+    for (const imp of imports) {
+      deps.add(imp)
+
+      const possibleExtensions = ['.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx']
+      for (const ext of possibleExtensions) {
+        const fullPath = imp + ext
+        if (existsSync(fullPath)) {
+          deps.add(fullPath)
+          const subDeps = getDependencies(fullPath, visited)
+          subDeps.forEach(d => deps.add(d))
+        }
+      }
+    }
+
+    return deps
+  }
+
+  for (const testFile of testFiles) {
+    const fullPath = resolve(PROJECT_ROOT, testFile)
+    const deps = getDependencies(fullPath, new Set())
+    graph.set(fullPath, deps)
+  }
+
+  return graph
+}
+
+function findRelatedTests(
+  changedFiles: ChangedFiles,
+  dependencyGraph: Map<string, Set<string>>
+): string[] {
+  const relatedTests = new Set<string>()
+  const allChanged = [...changedFiles.added, ...changedFiles.modified]
+
+  for (const changedFile of allChanged) {
+    const absolutePath = resolve(PROJECT_ROOT, changedFile)
+
+    for (const [testFile, dependencies] of Array.from(dependencyGraph.entries())) {
+      if (dependencies.has(absolutePath) || testFile.includes(changedFile)) {
+        relatedTests.add(testFile)
+      }
+    }
+  }
+
+  return Array.from(relatedTests)
+}
+
+function isInfrastructureTest(testFile: string): boolean {
+  const infrastructurePatterns = [
+    '/db/',
+    '/config',
+    '/driver',
+    '/test-setup',
+    'vitest.setup',
+    'vitest.integration.setup',
+  ]
+
+  return infrastructurePatterns.some(pattern => testFile.includes(pattern))
+}
+
+function runTests(testFiles: string[]): void {
+  if (testFiles.length === 0) {
+    console.log('✅ No related tests to run')
+    process.exit(0)
+  }
+
+  console.log('\n🎯 Running related tests:\n')
+  testFiles.forEach(file => {
+    const relativePath = relative(PROJECT_ROOT, file)
+    const type = isInfrastructureTest(file) ? '🏗️  [Infrastructure]' : '📦 [Business]'
+    console.log(`  ${type} ${relativePath}`)
+  })
+  console.log('')
+
+  const testPaths = testFiles.map(f => relative(PROJECT_ROOT, f))
+
+  try {
+    const command = `npx vitest run ${testPaths.map(p => `"${p}"`).join(' ')}`
+    console.log(`Executing: ${command}\n`)
+    execSync(command, { stdio: 'inherit' })
+    process.exit(0)
+  } catch (error) {
+    process.exit(1)
+  }
+}
+
+function main(): void {
+  const args = process.argv.slice(2)
+  const runAll = args.includes('--all')
+  const infrastructureOnly = args.includes('--infrastructure')
+
+  if (runAll) {
+    console.log('🏃 Running all tests...\n')
+    execSync('npx vitest run', { stdio: 'inherit' })
+    process.exit(0)
+  }
+
+  console.log('🔍 Analyzing changes...')
+
+  const changedFiles = getChangedFiles()
+  const allChanged = [...changedFiles.added, ...changedFiles.modified, ...changedFiles.deleted]
+
+  if (allChanged.length === 0) {
+    console.log('✅ No changes detected')
+    process.exit(0)
+  }
+
+  console.log('\n📝 Changed files:')
+  allChanged.forEach(file => console.log(`  - ${file}`))
+
+  console.log('\n🔍 Building dependency graph...')
+  const testFiles = findTestFiles()
+  const dependencyGraph = buildDependencyGraph(testFiles)
+
+  let relatedTests = findRelatedTests(changedFiles, dependencyGraph)
+
+  if (infrastructureOnly) {
+    relatedTests = relatedTests.filter(isInfrastructureTest)
+    console.log('\n🏗️  Filtering infrastructure tests only...')
+  }
+
+  runTests(relatedTests)
+}
+
+main()

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

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+
+import {
+  loadIndex,
+  loadRunRecord,
+  loadLatestRecord,
+  type TestRunRecord,
+  type TestCaseResult,
+} from './test-tracker.js'
+import { execSync } from 'child_process'
+
+function formatTimestamp(isoString: string): string {
+  const date = new Date(isoString)
+  return date.toLocaleString('zh-CN', {
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+  })
+}
+
+function truncate(str: string, maxLength: number): string {
+  if (str.length <= maxLength) return str
+  return str.substring(0, maxLength - 3) + '...'
+}
+
+function printList(): void {
+  const index = loadIndex()
+
+  if (!index || index.runs.length === 0) {
+    console.log('📅 No test history found.')
+    console.log('\n💡 Run some tests with tracking enabled to see history.')
+    return
+  }
+
+  console.log(`📅 Test History (showing last ${Math.min(10, index.runs.length)} runs)\n`)
+
+  console.log(' Commit  | Branch      | Tests  | Status  | Message                        | Time')
+  console.log(
+    '---------|-------------|--------|---------|--------------------------------|------------------'
+  )
+
+  const recentRuns = index.runs.slice(0, 10)
+
+  for (const run of recentRuns) {
+    const status = run.failed === 0 ? '✅ Pass' : `❌ ${run.failed} fail`
+    const message = truncate(run.commitMessage, 30)
+    const time = formatTimestamp(run.timestamp)
+
+    console.log(
+      ` ${run.shortSha} | ${run.branch.padEnd(11)} | ${String(run.passed).padStart(2)}/${String(run.total).padStart(2)} | ${status.padEnd(7)} | ${message.padEnd(30)} | ${time}`
+    )
+  }
+
+  console.log(`\n📊 Total runs: ${index.totalRuns}`)
+}
+
+function printShow(sha?: string): void {
+  let record: TestRunRecord | null
+
+  if (sha) {
+    record = loadRunRecord(sha)
+    if (!record) {
+      console.log(`❌ No test record found for commit: ${sha}`)
+      return
+    }
+  } else {
+    record = loadLatestRecord()
+    if (!record) {
+      console.log('❌ No test records found.')
+      console.log('\n💡 Run some tests with tracking enabled first.')
+      return
+    }
+  }
+
+  console.log(`\n📋 Test Record: ${record.shortSha}`)
+  console.log('='.repeat(60))
+  console.log(`Commit:    ${record.commitSha}`)
+  console.log(`Message:   ${record.commitMessage}`)
+  console.log(`Author:    ${record.author}`)
+  console.log(`Branch:    ${record.branch}`)
+  console.log(`Time:      ${formatTimestamp(record.timestamp)}`)
+  console.log(`Node:      ${record.environment.nodeVersion}`)
+  console.log(`Platform:  ${record.environment.platform}`)
+  console.log('')
+  console.log(`Total:     ${record.totalTests}`)
+  console.log(`Passed:    ${record.passed}`)
+  console.log(`Failed:    ${record.failed}`)
+  console.log(`Skipped:   ${record.skipped}`)
+  console.log(`Duration:  ${(record.duration / 1000).toFixed(2)}s`)
+  console.log('')
+
+  const passedTests = record.testResults.filter(t => t.status === 'passed')
+  const failedTests = record.testResults.filter(t => t.status === 'failed')
+  const skippedTests = record.testResults.filter(t => t.status === 'skipped')
+
+  if (failedTests.length > 0) {
+    console.log('\n❌ Failed Tests:')
+    for (const test of failedTests) {
+      console.log(`  • ${test.name}`)
+      console.log(`    File: ${test.file}`)
+      if (test.error) {
+        const errorLines = test.error.split('\n').slice(0, 3)
+        for (const line of errorLines) {
+          console.log(`    ${line}`)
+        }
+      }
+    }
+  }
+
+  if (skippedTests.length > 0) {
+    console.log('\n⏭️  Skipped Tests:')
+    for (const test of skippedTests) {
+      console.log(`  • ${test.name}`)
+    }
+  }
+
+  if (passedTests.length > 0 && failedTests.length === 0) {
+    console.log('\n✅ All tests passed!')
+    console.log(`   ${passedTests.length} test(s) executed successfully.`)
+  }
+}
+
+function compareRecords(sha1: string, sha2: string): void {
+  const record1 = loadRunRecord(sha1)
+  const record2 = loadRunRecord(sha2)
+
+  if (!record1) {
+    console.log(`❌ No test record found for commit: ${sha1}`)
+    return
+  }
+
+  if (!record2) {
+    console.log(`❌ No test record found for commit: ${sha2}`)
+    return
+  }
+
+  console.log('\n📊 Comparing test results:')
+  console.log('='.repeat(60))
+  console.log(
+    `  From: ${record1.shortSha} "${truncate(record1.commitMessage, 30)}" (${formatTimestamp(record1.timestamp)})`
+  )
+  console.log(
+    `  To:   ${record2.shortSha} "${truncate(record2.commitMessage, 30)}" (${formatTimestamp(record2.timestamp)})`
+  )
+  console.log('')
+
+  console.log('📈 Summary:')
+  console.log(`  Tests:  ${record1.totalTests} → ${record2.totalTests}`)
+  console.log(`  Passed: ${record1.passed} → ${record2.passed}`)
+  console.log(`  Failed: ${record1.failed} → ${record2.failed}`)
+  console.log('')
+
+  const tests1 = new Map<string, TestCaseResult>()
+  const tests2 = new Map<string, TestCaseResult>()
+
+  for (const test of record1.testResults) {
+    tests1.set(test.name, test)
+  }
+
+  for (const test of record2.testResults) {
+    tests2.set(test.name, test)
+  }
+
+  const fixedTests: TestCaseResult[] = []
+  const newFailures: TestCaseResult[] = []
+  const newTests: TestCaseResult[] = []
+  const removedTests: string[] = []
+
+  for (const [name, test] of tests2) {
+    const prevTest = tests1.get(name)
+    if (!prevTest) {
+      newTests.push(test)
+    } else if (prevTest.status === 'failed' && test.status === 'passed') {
+      fixedTests.push(test)
+    } else if (prevTest.status === 'passed' && test.status === 'failed') {
+      newFailures.push(test)
+    }
+  }
+
+  for (const name of tests1.keys()) {
+    if (!tests2.has(name)) {
+      removedTests.push(name)
+    }
+  }
+
+  if (fixedTests.length > 0) {
+    console.log('✅ Fixed tests (now passing):')
+    for (const test of fixedTests) {
+      console.log(`  • ${test.name}`)
+    }
+    console.log('')
+  }
+
+  if (newFailures.length > 0) {
+    console.log('❌ New failures:')
+    for (const test of newFailures) {
+      console.log(`  • ${test.name}`)
+      if (test.error) {
+        const errorLines = test.error.split('\n').slice(0, 2)
+        for (const line of errorLines) {
+          console.log(`    ${line}`)
+        }
+      }
+    }
+    console.log('')
+  }
+
+  if (newTests.length > 0) {
+    console.log('🆕 New tests:')
+    for (const test of newTests) {
+      const status = test.status === 'passed' ? '✅' : test.status === 'failed' ? '❌' : '⏭️'
+      console.log(`  ${status} ${test.name}`)
+    }
+    console.log('')
+  }
+
+  if (removedTests.length > 0) {
+    console.log('🗑️  Removed tests:')
+    for (const name of removedTests) {
+      console.log(`  • ${name}`)
+    }
+    console.log('')
+  }
+
+  if (
+    fixedTests.length === 0 &&
+    newFailures.length === 0 &&
+    newTests.length === 0 &&
+    removedTests.length === 0
+  ) {
+    console.log('ℹ️  No significant changes detected between these commits.')
+  }
+}
+
+function showFailedHistory(): void {
+  const index = loadIndex()
+
+  if (!index || index.runs.length === 0) {
+    console.log('📅 No test history found.')
+    return
+  }
+
+  console.log('❌ Failed Tests History\n')
+
+  const failedByTest = new Map<
+    string,
+    Array<{ sha: string; message: string; time: string; error?: string }>
+  >()
+
+  for (const run of index.runs) {
+    if (run.failed > 0) {
+      const record = loadRunRecord(run.shortSha)
+      if (record) {
+        for (const test of record.testResults.filter(t => t.status === 'failed')) {
+          const history = failedByTest.get(test.name) || []
+          history.push({
+            sha: run.shortSha,
+            message: run.commitMessage,
+            time: formatTimestamp(run.timestamp),
+            error: test.error?.split('\n')[0],
+          })
+          failedByTest.set(test.name, history)
+        }
+      }
+    }
+  }
+
+  if (failedByTest.size === 0) {
+    console.log('✅ No failed tests found in history!')
+    return
+  }
+
+  for (const [testName, history] of failedByTest) {
+    console.log(`\n📝 ${testName}`)
+    console.log(`   Failed ${history.length} time(s)`)
+    console.log('   Commits:')
+    for (const h of history) {
+      console.log(`   • ${h.sha} - ${truncate(h.message, 40)} (${h.time})`)
+      if (h.error) {
+        console.log(`     Error: ${truncate(h.error, 60)}`)
+      }
+    }
+  }
+}
+
+function getCurrentCommitSha(): string {
+  try {
+    return execSync('git rev-parse --short HEAD', { encoding: 'utf-8' }).trim()
+  } catch {
+    return ''
+  }
+}
+
+function printUsage(): void {
+  console.log(`
+📖 Test History Commands
+
+Usage:
+  test-history <command> [arguments]
+
+Commands:
+  list              List all test history records (default)
+  show [sha]        Show test details for a commit (default: latest)
+  compare <sha1> <sha2>   Compare test results between two commits
+  failed            Show all tests that have failed in history
+  help              Show this help message
+
+Examples:
+  test-history list
+  test-history show
+  test-history show abc1234
+  test-history compare abc1234 def5678
+  test-history failed
+`)
+}
+
+function main(): void {
+  const args = process.argv.slice(2)
+  const command = args[0] || 'list'
+
+  switch (command) {
+    case 'list':
+    case 'ls':
+      printList()
+      break
+
+    case 'show':
+      printShow(args[1])
+      break
+
+    case 'compare':
+    case 'diff':
+      if (!args[1] || !args[2]) {
+        console.log('❌ Usage: test-history compare <sha1> <sha2>')
+        console.log('\n💡 Example: test-history compare abc1234 def5678')
+        process.exit(1)
+      }
+      compareRecords(args[1], args[2])
+      break
+
+    case 'failed':
+      showFailedHistory()
+      break
+
+    case 'help':
+    case '--help':
+    case '-h':
+      printUsage()
+      break
+
+    default:
+      console.log(`❌ Unknown command: ${command}`)
+      printUsage()
+      process.exit(1)
+  }
+}
+
+main()