@eduardbar/drift 1.3.0 → 1.5.0

package/src/types.ts

@@ -1,409 +1,79 @@
-import type { SourceFile } from 'ts-morph'
-
-export interface DriftIssue {
-  rule: string
-  severity: 'error' | 'warning' | 'info'
-  message: string
-  line: number
-  column: number
-  snippet: string
-}
-
-export interface FileReport {
-  path: string
-  issues: DriftIssue[]
-  score: number // 0–100, higher = more drift
-}
-
-export interface DriftReport {
-  scannedAt: string
-  targetPath: string
-  files: FileReport[]
-  totalIssues: number
-  totalScore: number
-  totalFiles: number
-  summary: {
-    errors: number
-    warnings: number
-    infos: number
-    byRule: Record<string, number>
-  }
-  quality: RepoQualityScore
-  maintenanceRisk: MaintenanceRiskMetrics
-}
-
-export interface RepoQualityScore {
-  overall: number
-  dimensions: {
-    architecture: number
-    complexity: number
-    'ai-patterns': number
-    testing: number
-  }
-}
-
-export interface RiskHotspot {
-  file: string
-  driftScore: number
-  complexityIssues: number
-  hasNearbyTests: boolean
-  changeFrequency: number
-  risk: number
-  reasons: string[]
-}
-
-export interface MaintenanceRiskMetrics {
-  score: number
-  level: 'low' | 'medium' | 'high' | 'critical'
-  hotspots: RiskHotspot[]
-  signals: {
-    highComplexityFiles: number
-    filesWithoutNearbyTests: number
-    frequentChangeFiles: number
-  }
-}
-
-export interface AIOutput {
-  summary: {
-    score: number
-    grade: string
-    total_issues: number
-    files_affected: number
-    files_clean: number
-    ai_likelihood: number
-    ai_code_smell_score: number
-  }
-  files_suspected: Array<{ path: string; ai_likelihood: number; triggers: string[] }>
-  priority_order: AIIssue[]
-  maintenance_risk: MaintenanceRiskMetrics
-  quality: RepoQualityScore
-  context_for_ai: {
-    project_type: string
-    scan_path: string
-    rules_detected: string[]
-    recommended_action: string
-  }
-}
-
-export interface AIIssue {
-  rank: number
-  file: string
-  line: number
-  rule: string
-  severity: string
-  message: string
-  snippet: string
-  fix_suggestion: string
-  effort: 'low' | 'medium' | 'high'
-}
-
-export type MergeRiskLevel = 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL'
-
-export interface TrustGatePolicyPreset {
-  branch: string
-  enabled?: boolean
-  minTrust?: number
-  maxRisk?: MergeRiskLevel
-}
-
-export interface TrustGatePolicyPack {
-  enabled?: boolean
-  minTrust?: number
-  maxRisk?: MergeRiskLevel
-}
-
-export interface TrustGatePolicyConfig {
-  enabled?: boolean
-  minTrust?: number
-  maxRisk?: MergeRiskLevel
-  presets?: TrustGatePolicyPreset[]
-  policyPacks?: Record<string, TrustGatePolicyPack>
-}
-
-export interface TrustReason {
-  label: string
-  detail: string
-  impact: number
-}
-
-export interface TrustFixPriority {
-  rank: number
-  rule: string
-  severity: DriftIssue['severity']
-  occurrences: number
-  estimated_trust_gain: number
-  effort: 'low' | 'medium' | 'high'
-  suggestion: string
-  confidence?: 'low' | 'medium' | 'high'
-  explanation?: string
-  systemic?: boolean
-}
-
-export interface TrustAdvancedComparison {
-  source: 'previous-trust-json' | 'snapshot-history'
-  trend: 'improving' | 'regressing' | 'stable'
-  summary: string
-  trust_delta?: number
-  previous_trust_score?: number
-  previous_merge_risk?: MergeRiskLevel
-  snapshot_score_delta?: number
-  snapshot_label?: string
-  snapshot_timestamp?: string
-}
-
-export interface TrustAdvancedContext {
-  comparison?: TrustAdvancedComparison
-  team_guidance: string[]
-}
-
-export interface TrustDiffContext {
-  baseRef: string
-  status: 'improved' | 'regressed' | 'neutral'
-  scoreDelta: number
-  newIssues: number
-  resolvedIssues: number
-  filesChanged: number
-  penalty: number
-  bonus: number
-  netImpact: number
-}
-
-export interface DriftTrustReport {
-  scannedAt: string
-  targetPath: string
-  trust_score: number
-  merge_risk: MergeRiskLevel
-  top_reasons: TrustReason[]
-  fix_priorities: TrustFixPriority[]
-  diff_context?: TrustDiffContext
-  advanced_context?: TrustAdvancedContext
-}
-
-export interface TrustKpiDiagnostic {
-  level: 'warning' | 'error'
-  code: 'path-not-found' | 'path-not-supported' | 'read-failed' | 'parse-failed' | 'invalid-shape' | 'invalid-diff-context'
-  message: string
-  file?: string
-}
-
-export interface TrustScoreStats {
-  average: number | null
-  median: number | null
-  min: number | null
-  max: number | null
-}
-
-export interface TrustDiffTrendSummary {
-  available: boolean
-  samples: number
-  statusDistribution: {
-    improved: number
-    regressed: number
-    neutral: number
-  }
-  scoreDelta: {
-    average: number | null
-    median: number | null
-  }
-  issues: {
-    newTotal: number
-    resolvedTotal: number
-    netNew: number
-  }
-}
-
-export interface TrustKpiReport {
-  generatedAt: string
-  input: string
-  files: {
-    matched: number
-    parsed: number
-    malformed: number
-  }
-  prsEvaluated: number
-  mergeRiskDistribution: Record<MergeRiskLevel, number>
-  trustScore: TrustScoreStats
-  highRiskRatio: number | null
-  diffTrend: TrustDiffTrendSummary
-  diagnostics: TrustKpiDiagnostic[]
-}
-
-// ---------------------------------------------------------------------------
-// Configuration
-// ---------------------------------------------------------------------------
-
-/**
- * Layer definition for architectural boundary enforcement.
- */
-export interface LayerDefinition {
-  name: string
-  patterns: string[]
-  canImportFrom: string[]
-}
-
-/**
- * Module boundary definition for cross-boundary enforcement.
- */
-export interface ModuleBoundary {
-  name: string
-  root: string
-  allowedExternalImports?: string[]
-}
-
-/**
- * Optional project-level configuration for drift.
- * Place in drift.config.ts (or .js / .json) at the project root.
- */
-export interface DriftConfig {
-  layers?: LayerDefinition[]
-  modules?: ModuleBoundary[]
-  plugins?: string[]
-  performance?: DriftPerformanceConfig
-  architectureRules?: {
-    controllerNoDb?: boolean
-    serviceNoHttp?: boolean
-    maxFunctionLines?: number
-  }
-  saas?: {
-    freeUserThreshold?: number
-    maxRunsPerWorkspacePerMonth?: number
-    maxReposPerWorkspace?: number
-    retentionDays?: number
-    strictActorEnforcement?: boolean
-    maxWorkspacesPerOrganizationByPlan?: {
-      free?: number
-      sponsor?: number
-      team?: number
-      business?: number
-    }
-  }
-  trustGate?: TrustGatePolicyConfig
-}
-
-export interface DriftPerformanceConfig {
-  lowMemory?: boolean
-  chunkSize?: number
-  maxFiles?: number
-  maxFileSizeKb?: number
-  includeSemanticDuplication?: boolean
-}
-
-export interface DriftAnalysisOptions {
-  lowMemory?: boolean
-  chunkSize?: number
-  maxFiles?: number
-  maxFileSizeKb?: number
-  includeSemanticDuplication?: boolean
-}
-
-export interface PluginRuleContext {
-  projectRoot: string
-  filePath: string
-  config?: DriftConfig
-}
-
-export interface DriftPluginRule {
-  id?: string
-  name: string
-  severity?: DriftIssue['severity']
-  weight?: number
-  detect: (file: SourceFile, context: PluginRuleContext) => DriftIssue[]
-  fix?: (issue: DriftIssue, file: SourceFile, context: PluginRuleContext) => DriftIssue | void
-}
-
-export interface DriftPlugin {
-  name: string
-  apiVersion?: number
-  capabilities?: Record<string, string | number | boolean>
-  rules: DriftPluginRule[]
-}
-
-export interface LoadedPlugin {
-  id: string
-  plugin: DriftPlugin
-}
-
-export interface PluginLoadError {
-  pluginId: string
-  pluginName?: string
-  ruleId?: string
-  code?: string
-  message: string
-}
-
-export interface PluginLoadWarning {
-  pluginId: string
-  pluginName?: string
-  ruleId?: string
-  code?: string
-  message: string
-}
-
-// ---------------------------------------------------------------------------
-// Diff
-// ---------------------------------------------------------------------------
-
-export interface FileDiff {
-  path: string            // path relativo al project root
-  scoreBefore: number
-  scoreAfter: number
-  scoreDelta: number      // positivo = empeoró (más deuda), negativo = mejoró
-  newIssues: DriftIssue[]
-  resolvedIssues: DriftIssue[]
-}
-
-export interface DriftDiff {
-  baseRef: string         // git ref del baseline (e.g. "HEAD~1", "main")
-  projectPath: string     // path absoluto del proyecto
-  scannedAt: string       // ISO timestamp
-  files: FileDiff[]       // solo archivos con cambios (delta != 0 o issues diff != 0)
-  totalScoreBefore: number
-  totalScoreAfter: number
-  totalDelta: number      // positivo = más deuda, negativo = menos deuda
-  newIssuesCount: number
-  resolvedIssuesCount: number
-}
-
-/** Historical analysis data for a single commit */
-export interface HistoricalAnalysis {
-  commitHash: string;
-  commitDate: Date;
-  author: string;
-  message: string;
-  files: FileReport[];
-  totalScore: number;
-  averageScore: number;
-}
-
-/** Trend data point for score evolution */
-export interface TrendDataPoint {
-  date: Date;
-  score: number;
-  fileCount: number;
-  avgIssuesPerFile: number;
-}
-
-/** Blame attribution data */
-export interface BlameAttribution {
-  author: string;
-  email: string;
-  commits: number;
-  linesChanged: number;
-  issuesIntroduced: number;
-  avgScoreImpact: number;
-}
-
-/** Extended DriftReport with historical context */
-export interface DriftTrendReport extends DriftReport {
-  trend: TrendDataPoint[];
-  regression: {
-    slope: number;
-    intercept: number;
-    r2: number;
-  };
-}
-
-/** Extended DriftReport with blame data */
-export interface DriftBlameReport extends DriftReport {
-  blame: BlameAttribution[];
-}
+// drift-ignore-file
+export type {
+  DriftIssue,
+  FileReport,
+  RepoQualityScore,
+  RiskHotspot,
+  MaintenanceRiskMetrics,
+  AIIssue,
+  AIOutput,
+  AIOutputJson,
+  DriftReport,
+  DriftReportJson,
+  DriftOutputMetadata,
+} from './types/core.js'
+
+export type {
+  MergeRiskLevel,
+  TrustGatePolicyPreset,
+  TrustGatePolicyPack,
+  TrustGatePolicyConfig,
+  TrustReason,
+  TrustFixPriority,
+  TrustAdvancedComparison,
+  TrustAdvancedContext,
+  TrustDiffContext,
+  DriftTrustReport,
+  DriftTrustReportJson,
+  TrustKpiDiagnostic,
+  TrustScoreStats,
+  TrustDiffTrendSummary,
+  TrustKpiReport,
+} from './types/trust.js'
+
+export type {
+  LayerDefinition,
+  ModuleBoundary,
+  DriftPerformanceConfig,
+  DriftAnalysisOptions,
+} from './types/config.js'
+
+export type { DriftConfig } from './types/app.js'
+
+export type {
+  PluginRuleContext,
+  DriftPluginRule,
+  DriftPlugin,
+  LoadedPlugin,
+  PluginLoadError,
+  PluginLoadWarning,
+} from './types/plugin.js'
+
+export type {
+  FileDiff,
+  DriftDiff,
+  HistoricalAnalysis,
+  TrendDataPoint,
+  BlameAttribution,
+  DriftTrendReport,
+  DriftBlameReport,
+} from './types/diff.js'
+
+export type {
+  GuardBaseline,
+  GuardThresholds,
+  GuardOptions,
+  GuardMetrics,
+  GuardCheck,
+  GuardEvaluation,
+  GuardResult,
+  GuardResultJson,
+} from './guard-types.js'
+
+export type {
+  SarifLevel,
+  DriftSarifRule,
+  DriftSarifResult,
+  DriftSarifRun,
+  DriftSarifLog,
+} from './sarif.js'

package/tests/ci-quality-matrix.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const repoRoot = process.cwd()
+
+function readRepoFile(path: string): string {
+  return readFileSync(join(repoRoot, path), 'utf8')
+}
+
+describe('CI quality matrix contract', () => {
+  it('requires Node 20/22 in reusable and entry workflows', () => {
+    const reusable = readRepoFile('.github/workflows/reusable-quality-checks.yml')
+    const quality = readRepoFile('.github/workflows/quality.yml')
+
+    expect(reusable).toContain("default: '[\"20\", \"22\"]'")
+    expect(quality).toContain("node_versions: '[\"20\", \"22\"]'")
+    expect(quality).toContain('pull_request:')
+    expect(quality).toContain('branches: [main, master]')
+    expect(quality).toContain('uses: ./.github/workflows/reusable-quality-checks.yml')
+  })
+
+  it('includes required quality commands in reusable checks', () => {
+    const reusable = readRepoFile('.github/workflows/reusable-quality-checks.yml')
+
+    expect(reusable).toContain('run: npm ci')
+    expect(reusable).toContain('run: npm run check:runtime-policy')
+    expect(reusable).toContain('run: npm run check:docs-drift')
+    expect(reusable).toContain("if: matrix.node == '20'")
+    expect(reusable).toContain('run: npm run check:perf-budget -- --out .drift-perf/ci-node-${{ matrix.node }}/benchmark-latest.json')
+    expect(reusable).toContain('run: npm test')
+    expect(reusable).toContain('run: npm run test:coverage')
+    expect(reusable).toContain('run: npm run build')
+    expect(reusable).toContain('name: Upload perf gate artifacts')
+    expect(reusable).toContain('path: .drift-perf/ci-node-${{ matrix.node }}/')
+  })
+})

package/tests/ci-smoke-gate.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const repoRoot = process.cwd()
+
+function readRepoFile(path: string): string {
+  return readFileSync(join(repoRoot, path), 'utf8')
+}
+
+describe('CI smoke E2E gate', () => {
+  it('runs smoke:repo in reusable quality checks', () => {
+    const workflow = readRepoFile('.github/workflows/reusable-quality-checks.yml')
+
+    expect(workflow).toContain('name: Run CLI smoke E2E')
+    expect(workflow).toContain('run: npm run smoke:repo -- --base HEAD --out .drift-smoke/ci-node-${{ matrix.node }}')
+  })
+
+  it('uploads smoke artifacts even when smoke fails', () => {
+    const workflow = readRepoFile('.github/workflows/reusable-quality-checks.yml')
+
+    expect(workflow).toContain('name: Upload smoke E2E artifacts')
+    expect(workflow).toContain('if: always()')
+    expect(workflow).toContain('path: .drift-smoke/ci-node-${{ matrix.node }}/')
+  })
+})

package/tests/ci-version-alignment.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const repoRoot = process.cwd()
+
+function readRepoFile(path: string): string {
+  return readFileSync(join(repoRoot, path), 'utf8')
+}
+
+function getPackageVersion(): string {
+  const pkg = JSON.parse(readRepoFile('package.json')) as { version?: unknown }
+  if (typeof pkg.version !== 'string' || pkg.version.length === 0) {
+    throw new Error('package.json is missing a valid version field')
+  }
+  return pkg.version
+}
+
+function extractVersionDefaultFromAction(content: string): string | undefined {
+  const lines = content.split(/\r?\n/)
+  const versionLine = lines.findIndex((line) => line.trim() === 'version:')
+  if (versionLine === -1) {
+    return undefined
+  }
+
+  for (let index = versionLine + 1; index < lines.length; index += 1) {
+    const trimmed = lines[index].trim()
+    if (trimmed.endsWith(':') && !trimmed.startsWith('default:')) {
+      break
+    }
+    const match = trimmed.match(/^default:\s*['"](\d+\.\d+\.\d+)['"]$/)
+    if (match) {
+      return match[1]
+    }
+  }
+
+  return undefined
+}
+
+describe('CI drift version alignment', () => {
+  it('keeps action version defaults aligned with package version', () => {
+    const packageVersion = getPackageVersion()
+    const actionFiles = ['.github/actions/drift-scan/action.yml', '.github/actions/drift-review/action.yml']
+
+    for (const actionFile of actionFiles) {
+      const content = readRepoFile(actionFile)
+      const actionVersion = extractVersionDefaultFromAction(content)
+      expect(actionVersion, `${actionFile} version default must match package.json`).toBe(packageVersion)
+    }
+  })
+
+  it('keeps documented action versions aligned with package version', () => {
+    const packageVersion = getPackageVersion()
+    const docs = ['.github/actions/drift-scan/README.md', '.github/actions/drift-review/README.md']
+    const versionRegex = /\b(\d+\.\d+\.\d+)\b/g
+
+    for (const doc of docs) {
+      const content = readRepoFile(doc)
+      const versions = Array.from(content.matchAll(versionRegex), (match) => match[1])
+
+      expect(versions.length, `${doc} should include at least one semver literal`).toBeGreaterThan(0)
+      expect(new Set(versions), `${doc} semver literals must match package.json`).toEqual(new Set([packageVersion]))
+    }
+  })
+
+  it('rejects hardcoded drift package semvers that diverge in CI yaml files', () => {
+    const packageVersion = getPackageVersion()
+    const yamlFiles = [
+      '.github/actions/drift-scan/action.yml',
+      '.github/actions/drift-review/action.yml',
+      '.github/workflows/quality.yml',
+      '.github/workflows/reusable-quality-checks.yml',
+      '.github/workflows/review-pr.yml',
+      '.github/workflows/publish.yml',
+      '.github/workflows/publish-vscode.yml',
+    ]
+
+    const mismatches: string[] = []
+    const packageRefRegex = /@eduardbar\/drift@(\d+\.\d+\.\d+)/g
+
+    for (const yamlFile of yamlFiles) {
+      const content = readRepoFile(yamlFile)
+      for (const match of content.matchAll(packageRefRegex)) {
+        const version = match[1]
+        if (version !== packageVersion) {
+          mismatches.push(`${yamlFile}: ${version}`)
+        }
+      }
+    }
+
+    expect(mismatches).toEqual([])
+  })
+})