@eduardbar/drift 1.2.0 → 1.3.0

package/src/diff.ts

@@ -1,9 +1,26 @@
 import type { DriftReport, DriftDiff, FileDiff, DriftIssue } from './types.js'
 
+function normalizePath(filePath: string): string {
+  return filePath.replace(/\\/g, '/')
+}
+
+function normalizeIssueText(value: string): string {
+  return value
+    .replace(/\r\n/g, '\n')
+    .replace(/\r/g, '\n')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
 /**
  * Compute the diff between two DriftReports.
  *
- * Issues are matched by (rule + line + column) as a unique key within a file.
+ * Issues are matched in two passes:
+ * 1) strict location key (rule + line + column)
+ * 2) normalized content key (rule + severity + line + message + snippet)
+ *
+ * This keeps deterministic matching while preventing false churn caused by
+ * cross-platform line ending changes and small column offset noise.
  * A "new" issue exists in `current` but not in `base`.
  * A "resolved" issue exists in `base` but not in `current`.
  */
@@ -19,13 +36,61 @@ function computeFileDiff(
   const baseIssues = baseFile?.issues ?? []
   const currentIssues = currentFile?.issues ?? []
 
-  const issueKey = (i: DriftIssue) => `${i.rule}:${i.line}:${i.column}`
+  const strictIssueKey = (i: DriftIssue) => `${i.rule}:${i.line}:${i.column}`
+  const normalizedIssueKey = (i: DriftIssue) => {
+    const normalizedMessage = normalizeIssueText(i.message)
+    const normalizedSnippetPrefix = normalizeIssueText(i.snippet).slice(0, 80)
+    return `${i.rule}:${i.severity}:${i.line}:${normalizedMessage}:${normalizedSnippetPrefix}`
+  }
+
+  const matchedBaseIndexes = new Set<number>()
+  const matchedCurrentIndexes = new Set<number>()
+
+  const baseStrictIndex = new Map<string, number[]>()
+  for (const [index, issue] of baseIssues.entries()) {
+    const key = strictIssueKey(issue)
+    const bucket = baseStrictIndex.get(key)
+    if (bucket) bucket.push(index)
+    else baseStrictIndex.set(key, [index])
+  }
+
+  for (const [currentIndex, issue] of currentIssues.entries()) {
+    const key = strictIssueKey(issue)
+    const bucket = baseStrictIndex.get(key)
+    if (!bucket || bucket.length === 0) continue
 
-  const baseKeys = new Set(baseIssues.map(issueKey))
-  const currentKeys = new Set(currentIssues.map(issueKey))
+    const matchedIndex = bucket.shift()
+    if (matchedIndex === undefined) continue
+
+    matchedBaseIndexes.add(matchedIndex)
+    matchedCurrentIndexes.add(currentIndex)
+  }
+
+  const baseNormalizedIndex = new Map<string, number[]>()
+  for (const [index, issue] of baseIssues.entries()) {
+    if (matchedBaseIndexes.has(index)) continue
+    const key = normalizedIssueKey(issue)
+    const bucket = baseNormalizedIndex.get(key)
+    if (bucket) bucket.push(index)
+    else baseNormalizedIndex.set(key, [index])
+  }
+
+  for (const [currentIndex, issue] of currentIssues.entries()) {
+    if (matchedCurrentIndexes.has(currentIndex)) continue
+
+    const key = normalizedIssueKey(issue)
+    const bucket = baseNormalizedIndex.get(key)
+    if (!bucket || bucket.length === 0) continue
+
+    const matchedIndex = bucket.shift()
+    if (matchedIndex === undefined) continue
+
+    matchedBaseIndexes.add(matchedIndex)
+    matchedCurrentIndexes.add(currentIndex)
+  }
 
-  const newIssues = currentIssues.filter(i => !baseKeys.has(issueKey(i)))
-  const resolvedIssues = baseIssues.filter(i => !currentKeys.has(issueKey(i)))
+  const newIssues = currentIssues.filter((_, index) => !matchedCurrentIndexes.has(index))
+  const resolvedIssues = baseIssues.filter((_, index) => !matchedBaseIndexes.has(index))
 
   if (scoreDelta !== 0 || newIssues.length > 0 || resolvedIssues.length > 0) {
     return {
@@ -48,12 +113,12 @@ export function computeDiff(
 ): DriftDiff {
   const fileDiffs: FileDiff[] = []
 
-  const baseByPath = new Map(base.files.map(f => [f.path, f]))
-  const currentByPath = new Map(current.files.map(f => [f.path, f]))
+  const baseByPath = new Map(base.files.map(f => [normalizePath(f.path), f]))
+  const currentByPath = new Map(current.files.map(f => [normalizePath(f.path), f]))
 
   const allPaths = new Set([
-    ...base.files.map(f => f.path),
-    ...current.files.map(f => f.path),
+    ...base.files.map(f => normalizePath(f.path)),
+    ...current.files.map(f => normalizePath(f.path)),
   ])
 
   for (const filePath of allPaths) {

package/src/git.ts

@@ -63,6 +63,18 @@ function extractFile(projectPath: string, ref: string, filePath: string, tempDir
   writeFileSync(destPath, content, 'utf-8')
 }
 
+function extractArchiveAtRef(projectPath: string, ref: string, tempDir: string): boolean {
+  try {
+    execSync(
+      `git archive --format=tar ${ref} | tar -x -C "${tempDir}"`,
+      { cwd: projectPath, stdio: 'pipe' }
+    )
+    return true
+  } catch {
+    return false
+  }
+}
+
 export function extractFilesAtRef(projectPath: string, ref: string): string {
   verifyGitRepo(projectPath)
   verifyRefExists(projectPath, ref)
@@ -76,6 +88,10 @@ export function extractFilesAtRef(projectPath: string, ref: string): string {
   const tempDir = join(tmpdir(), `drift-diff-${randomUUID()}`)
   mkdirSync(tempDir, { recursive: true })
 
+  if (extractArchiveAtRef(projectPath, ref, tempDir)) {
+    return tempDir
+  }
+
   for (const filePath of tsFiles) {
     extractFile(projectPath, ref, filePath, tempDir)
   }

package/src/index.ts

@@ -2,6 +2,22 @@ export { analyzeProject, analyzeFile, RULE_WEIGHTS } from './analyzer.js'
 export { buildReport, formatMarkdown } from './reporter.js'
 export { computeDiff } from './diff.js'
 export { generateReview, formatReviewMarkdown } from './review.js'
+export {
+  buildTrustReport,
+  formatTrustConsole,
+  formatTrustMarkdown,
+  formatTrustJson,
+  shouldFailByMaxRisk,
+  shouldFailTrustGate,
+  normalizeMergeRiskLevel,
+  MERGE_RISK_ORDER,
+} from './trust.js'
+export {
+  computeTrustKpis,
+  computeTrustKpisFromReports,
+  formatTrustKpiConsole,
+  formatTrustKpiJson,
+} from './trust-kpi.js'
 export { generateArchitectureMap, generateArchitectureSvg } from './map.js'
 export type {
   DriftReport,
@@ -12,6 +28,15 @@ export type {
   DriftConfig,
   RepoQualityScore,
   MaintenanceRiskMetrics,
+  DriftTrustReport,
+  TrustReason,
+  TrustFixPriority,
+  TrustDiffContext,
+  TrustKpiReport,
+  TrustKpiDiagnostic,
+  TrustDiffTrendSummary,
+  TrustScoreStats,
+  MergeRiskLevel,
   DriftPlugin,
   DriftPluginRule,
 } from './types.js'
@@ -21,14 +46,37 @@ export {
   DEFAULT_SAAS_POLICY,
   defaultSaasStorePath,
   resolveSaasPolicy,
+  SaasActorRequiredError,
+  SaasPermissionError,
+  getRequiredRoleForOperation,
+  assertSaasPermission,
+  getSaasEffectiveLimits,
+  getOrganizationEffectiveLimits,
+  changeOrganizationPlan,
+  listOrganizationPlanChanges,
+  getOrganizationUsageSnapshot,
   ingestSnapshotFromReport,
+  listSaasSnapshots,
   getSaasSummary,
   generateSaasDashboardHtml,
 } from './saas.js'
 export type {
+  SaasRole,
+  SaasPlan,
   SaasPolicy,
+  SaasPolicyOverrides,
   SaasStore,
   SaasSummary,
   SaasSnapshot,
+  SaasQueryOptions,
   IngestOptions,
+  SaasPlanChange,
+  SaasOperation,
+  SaasPermissionContext,
+  SaasPermissionResult,
+  SaasEffectiveLimits,
+  SaasOrganizationUsageSnapshot,
+  ChangeOrganizationPlanOptions,
+  SaasUsageQueryOptions,
+  SaasPlanChangeQueryOptions,
 } from './saas.js'

package/src/plugins.ts

@@ -1,30 +1,353 @@
 import { existsSync } from 'node:fs'
 import { isAbsolute, resolve } from 'node:path'
 import { createRequire } from 'node:module'
-import type { DriftPlugin, PluginLoadError, LoadedPlugin } from './types.js'
+import type { DriftIssue, DriftPlugin, DriftPluginRule, PluginLoadError, PluginLoadWarning, LoadedPlugin } from './types.js'
 
 const require = createRequire(import.meta.url)
+const VALID_SEVERITIES: DriftIssue['severity'][] = ['error', 'warning', 'info']
+const SUPPORTED_PLUGIN_API_VERSION = 1
+const RULE_ID_REQUIRED = /^[a-z][a-z0-9]*(?:[-_/][a-z0-9]+)*$/
 
-function isPluginShape(value: unknown): value is DriftPlugin {
-  if (!value || typeof value !== 'object') return false
-  const candidate = value as Partial<DriftPlugin>
-  if (typeof candidate.name !== 'string') return false
-  if (!Array.isArray(candidate.rules)) return false
-  return candidate.rules.every((rule) =>
-    rule &&
-    typeof rule === 'object' &&
-    typeof rule.name === 'string' &&
-    typeof rule.detect === 'function'
-  )
+type PluginCandidate = {
+  name?: unknown
+  apiVersion?: unknown
+  capabilities?: unknown
+  rules?: unknown
 }
 
-function normalizePluginExport(mod: unknown): DriftPlugin | undefined {
-  if (isPluginShape(mod)) return mod
+type RuleCandidate = {
+  id?: unknown
+  name?: unknown
+  severity?: unknown
+  weight?: unknown
+  detect?: unknown
+  fix?: unknown
+}
+
+function normalizePluginExport(mod: unknown): unknown {
   if (mod && typeof mod === 'object' && 'default' in mod) {
-    const maybeDefault = (mod as { default?: unknown }).default
-    if (isPluginShape(maybeDefault)) return maybeDefault
+    return (mod as { default?: unknown }).default ?? mod
+  }
+  return mod
+}
+
+function pushError(
+  errors: PluginLoadError[],
+  pluginId: string,
+  message: string,
+  options?: { pluginName?: string; ruleId?: string; code?: string },
+): void {
+  errors.push({
+    pluginId,
+    pluginName: options?.pluginName,
+    ruleId: options?.ruleId,
+    code: options?.code,
+    message,
+  })
+}
+
+function pushWarning(
+  warnings: PluginLoadWarning[],
+  pluginId: string,
+  message: string,
+  options?: { pluginName?: string; ruleId?: string; code?: string },
+): void {
+  warnings.push({
+    pluginId,
+    pluginName: options?.pluginName,
+    ruleId: options?.ruleId,
+    code: options?.code,
+    message,
+  })
+}
+
+function normalizeRule(
+  pluginId: string,
+  pluginName: string,
+  rawRule: RuleCandidate,
+  ruleIndex: number,
+  options: { strictRuleId: boolean },
+  errors: PluginLoadError[],
+  warnings: PluginLoadWarning[],
+): DriftPluginRule | undefined {
+  const rawRuleId = typeof rawRule.id === 'string'
+    ? rawRule.id.trim()
+    : typeof rawRule.name === 'string'
+      ? rawRule.name.trim()
+      : ''
+
+  const ruleLabel = rawRuleId || `rule#${ruleIndex + 1}`
+
+  if (!rawRuleId) {
+    pushError(
+      errors,
+      pluginId,
+      `Invalid rule at index ${ruleIndex}. Expected 'id' or 'name' as a non-empty string.`,
+      { pluginName, code: 'plugin-rule-id-missing' },
+    )
+    return undefined
+  }
+
+  if (typeof rawRule.detect !== 'function') {
+    pushError(
+      errors,
+      pluginId,
+      `Rule '${rawRuleId}' is invalid. Expected 'detect(file, context)' function.`,
+      { pluginName, ruleId: rawRuleId, code: 'plugin-rule-detect-invalid' },
+    )
+    return undefined
+  }
+
+  if (rawRule.detect.length > 2) {
+    pushWarning(
+      warnings,
+      pluginId,
+      `Rule '${rawRuleId}' detect() declares ${rawRule.detect.length} parameters. Expected 1-2 parameters (file, context).`,
+      { pluginName, ruleId: rawRuleId, code: 'plugin-rule-detect-arity' },
+    )
+  }
+
+  if (!RULE_ID_REQUIRED.test(rawRuleId)) {
+    if (options.strictRuleId) {
+      pushError(
+        errors,
+        pluginId,
+        `Rule id '${ruleLabel}' is invalid. Use lowercase letters, numbers, and separators (-, _, /), starting with a letter.`,
+        { pluginName, ruleId: rawRuleId, code: 'plugin-rule-id-invalid' },
+      )
+      return undefined
+    }
+
+    pushWarning(
+      warnings,
+      pluginId,
+      `Rule id '${ruleLabel}' uses a legacy format. For forward compatibility, migrate to lowercase kebab-case and set apiVersion: ${SUPPORTED_PLUGIN_API_VERSION}.`,
+      { pluginName, ruleId: rawRuleId, code: 'plugin-rule-id-format-legacy' },
+    )
+  }
+
+  let severity: DriftIssue['severity'] | undefined
+  if (rawRule.severity !== undefined) {
+    if (typeof rawRule.severity === 'string' && VALID_SEVERITIES.includes(rawRule.severity as DriftIssue['severity'])) {
+      severity = rawRule.severity as DriftIssue['severity']
+    } else {
+      pushError(
+        errors,
+        pluginId,
+        `Rule '${rawRuleId}' has invalid severity '${String(rawRule.severity)}'. Allowed: error, warning, info.`,
+        { pluginName, ruleId: rawRuleId, code: 'plugin-rule-severity-invalid' },
+      )
+    }
+  }
+
+  let weight: number | undefined
+  if (rawRule.weight !== undefined) {
+    if (typeof rawRule.weight === 'number' && Number.isFinite(rawRule.weight) && rawRule.weight >= 0 && rawRule.weight <= 100) {
+      weight = rawRule.weight
+    } else {
+      pushError(
+        errors,
+        pluginId,
+        `Rule '${rawRuleId}' has invalid weight '${String(rawRule.weight)}'. Expected a finite number between 0 and 100.`,
+        { pluginName, ruleId: rawRuleId, code: 'plugin-rule-weight-invalid' },
+      )
+    }
+  }
+
+  let fix: DriftPluginRule['fix'] | undefined
+  if (rawRule.fix !== undefined) {
+    if (typeof rawRule.fix === 'function') {
+      fix = rawRule.fix as DriftPluginRule['fix']
+      if (rawRule.fix.length > 3) {
+        pushWarning(
+          warnings,
+          pluginId,
+          `Rule '${rawRuleId}' fix() declares ${rawRule.fix.length} parameters. Expected up to 3 (issue, file, context).`,
+          { pluginName, ruleId: rawRuleId, code: 'plugin-rule-fix-arity' },
+        )
+      }
+    } else {
+      pushError(
+        errors,
+        pluginId,
+        `Rule '${rawRuleId}' has invalid fix. Expected a function when provided.`,
+        { pluginName, ruleId: rawRuleId, code: 'plugin-rule-fix-invalid' },
+      )
+    }
+  }
+
+  return {
+    id: rawRuleId,
+    name: rawRuleId,
+    detect: rawRule.detect as DriftPluginRule['detect'],
+    severity,
+    weight,
+    fix,
+  }
+}
+
+function validatePluginContract(
+  pluginId: string,
+  candidate: unknown,
+): {
+  plugin?: DriftPlugin
+  errors: PluginLoadError[]
+  warnings: PluginLoadWarning[]
+} {
+  const errors: PluginLoadError[] = []
+  const warnings: PluginLoadWarning[] = []
+
+  if (!candidate || typeof candidate !== 'object') {
+    pushError(
+      errors,
+      pluginId,
+      `Invalid plugin contract in '${pluginId}'. Expected an object export with shape { name, rules[] }`,
+      { code: 'plugin-shape-invalid' },
+    )
+    return { errors, warnings }
+  }
+
+  const plugin = candidate as PluginCandidate
+  const pluginName = typeof plugin.name === 'string' ? plugin.name.trim() : ''
+  if (!pluginName) {
+    pushError(
+      errors,
+      pluginId,
+      `Invalid plugin contract in '${pluginId}'. Expected 'name' as a non-empty string.`,
+      { code: 'plugin-name-missing' },
+    )
+    return { errors, warnings }
+  }
+
+  const hasExplicitApiVersion = plugin.apiVersion !== undefined
+  const isLegacyPlugin = !hasExplicitApiVersion
+
+  if (isLegacyPlugin) {
+    pushWarning(
+      warnings,
+      pluginId,
+      `Plugin '${pluginName}' does not declare 'apiVersion'. Assuming ${SUPPORTED_PLUGIN_API_VERSION} for backward compatibility; please add apiVersion: ${SUPPORTED_PLUGIN_API_VERSION}.`,
+      { pluginName, code: 'plugin-api-version-implicit' },
+    )
+  } else if (typeof plugin.apiVersion !== 'number' || !Number.isInteger(plugin.apiVersion) || plugin.apiVersion <= 0) {
+    pushError(
+      errors,
+      pluginId,
+      `Plugin '${pluginName}' has invalid apiVersion '${String(plugin.apiVersion)}'. Expected a positive integer (for example: ${SUPPORTED_PLUGIN_API_VERSION}).`,
+      { pluginName, code: 'plugin-api-version-invalid' },
+    )
+    return { errors, warnings }
+  } else if (plugin.apiVersion !== SUPPORTED_PLUGIN_API_VERSION) {
+    pushError(
+      errors,
+      pluginId,
+      `Plugin '${pluginName}' targets apiVersion ${plugin.apiVersion}, but this drift build supports apiVersion ${SUPPORTED_PLUGIN_API_VERSION}.`,
+      { pluginName, code: 'plugin-api-version-unsupported' },
+    )
+    return { errors, warnings }
+  }
+
+  let capabilities: DriftPlugin['capabilities'] | undefined
+  if (plugin.capabilities !== undefined) {
+    if (!plugin.capabilities || typeof plugin.capabilities !== 'object' || Array.isArray(plugin.capabilities)) {
+      pushError(
+        errors,
+        pluginId,
+        `Plugin '${pluginName}' has invalid capabilities metadata. Expected an object map like { "fixes": true } when provided.`,
+        { pluginName, code: 'plugin-capabilities-invalid' },
+      )
+      return { errors, warnings }
+    }
+
+    const entries = Object.entries(plugin.capabilities as Record<string, unknown>)
+    for (const [capabilityKey, capabilityValue] of entries) {
+      const capabilityType = typeof capabilityValue
+      if (capabilityType !== 'string' && capabilityType !== 'number' && capabilityType !== 'boolean') {
+        pushError(
+          errors,
+          pluginId,
+          `Plugin '${pluginName}' capability '${capabilityKey}' has invalid value type '${capabilityType}'. Allowed: string | number | boolean.`,
+          { pluginName, code: 'plugin-capabilities-value-invalid' },
+        )
+      }
+    }
+
+    if (errors.length > 0) {
+      return { errors, warnings }
+    }
+
+    capabilities = plugin.capabilities as DriftPlugin['capabilities']
+  }
+
+  if (!Array.isArray(plugin.rules)) {
+    pushError(
+      errors,
+      pluginId,
+      `Invalid plugin '${pluginName}'. Expected 'rules' to be an array.`,
+      { pluginName, code: 'plugin-rules-not-array' },
+    )
+    return { errors, warnings }
+  }
+
+  const normalizedRules: DriftPluginRule[] = []
+  const seenRuleIds = new Set<string>()
+
+  for (const [ruleIndex, rawRule] of plugin.rules.entries()) {
+    if (!rawRule || typeof rawRule !== 'object') {
+      pushError(
+        errors,
+        pluginId,
+        `Invalid rule at index ${ruleIndex} in plugin '${pluginName}'. Expected an object.`,
+        { pluginName, code: 'plugin-rule-shape-invalid' },
+      )
+      continue
+    }
+
+    const normalized = normalizeRule(
+      pluginId,
+      pluginName,
+      rawRule as RuleCandidate,
+      ruleIndex,
+      { strictRuleId: !isLegacyPlugin },
+      errors,
+      warnings,
+    )
+    if (normalized) {
+      if (seenRuleIds.has(normalized.id ?? normalized.name)) {
+        pushError(
+          errors,
+          pluginId,
+          `Plugin '${pluginName}' defines duplicate rule id '${normalized.id ?? normalized.name}'. Rule ids must be unique within a plugin.`,
+          { pluginName, ruleId: normalized.id ?? normalized.name, code: 'plugin-rule-id-duplicate' },
+        )
+        continue
+      }
+
+      seenRuleIds.add(normalized.id ?? normalized.name)
+      normalizedRules.push(normalized)
+    }
+  }
+
+  if (normalizedRules.length === 0) {
+    pushError(
+      errors,
+      pluginId,
+      `Plugin '${pluginName}' has no valid rules after validation.`,
+      { pluginName, code: 'plugin-rules-empty' },
+    )
+    return { errors, warnings }
+  }
+
+  return {
+    plugin: {
+      name: pluginName,
+      apiVersion: hasExplicitApiVersion ? plugin.apiVersion as number : SUPPORTED_PLUGIN_API_VERSION,
+      capabilities,
+      rules: normalizedRules,
+    },
+    errors,
+    warnings,
   }
-  return undefined
 }
 
 function resolvePluginSpecifier(projectRoot: string, pluginId: string): string {
@@ -43,34 +366,39 @@ function resolvePluginSpecifier(projectRoot: string, pluginId: string): string {
 export function loadPlugins(projectRoot: string, pluginIds: string[] | undefined): {
   plugins: LoadedPlugin[]
   errors: PluginLoadError[]
+  warnings: PluginLoadWarning[]
 } {
   if (!pluginIds || pluginIds.length === 0) {
-    return { plugins: [], errors: [] }
+    return { plugins: [], errors: [], warnings: [] }
   }
 
   const loaded: LoadedPlugin[] = []
   const errors: PluginLoadError[] = []
+  const warnings: PluginLoadWarning[] = []
 
   for (const pluginId of pluginIds) {
     const resolved = resolvePluginSpecifier(projectRoot, pluginId)
     try {
       const mod = require(resolved)
-      const plugin = normalizePluginExport(mod)
-      if (!plugin) {
-        errors.push({
-          pluginId,
-          message: `Invalid plugin contract in '${pluginId}'. Expected: { name, rules[] }`,
-        })
+      const normalized = normalizePluginExport(mod)
+      const validation = validatePluginContract(pluginId, normalized)
+
+      errors.push(...validation.errors)
+      warnings.push(...validation.warnings)
+
+      if (!validation.plugin) {
         continue
       }
-      loaded.push({ id: pluginId, plugin })
+
+      loaded.push({ id: pluginId, plugin: validation.plugin })
     } catch (error) {
       errors.push({
         pluginId,
+        code: 'plugin-load-failed',
         message: error instanceof Error ? error.message : String(error),
       })
     }
   }
 
-  return { plugins: loaded, errors }
+  return { plugins: loaded, errors, warnings }
 }

package/src/printer.ts

@@ -133,6 +133,10 @@ function formatFixSuggestion(issue: DriftIssue): string[] {
       'Fix or remove the failing plugin in drift.config.*',
       'Validate plugin contract: export { name, rules[] } and detector functions',
     ],
+    'plugin-warning': [
+      'Review plugin validation warnings and align with the recommended contract',
+      'Use explicit rule ids and valid severity/weight values',
+    ],
   }
   return suggestions[issue.rule] ?? ['Review and fix manually']
 }

package/src/review.ts

@@ -1,4 +1,4 @@
-import { resolve } from 'node:path'
+import { relative, resolve } from 'node:path'
 import { analyzeProject } from './analyzer.js'
 import { loadConfig } from './config.js'
 import { buildReport } from './reporter.js'
@@ -66,7 +66,7 @@ export async function generateReview(projectPath: string, baseRef: string): Prom
       ...baseReport,
       files: baseReport.files.map((file) => ({
         ...file,
-        path: file.path.replace(tempDir!, resolvedPath),
+        path: resolve(resolvedPath, relative(tempDir!, file.path)),
       })),
     }
 

package/src/rules/comments.ts

@@ -1,6 +1,6 @@
 import { SourceFile } from 'ts-morph'
 import type { DriftIssue } from '../types.js'
-import { hasIgnoreComment } from './shared.js'
+import { hasIgnoreComment, getFileLines } from './shared.js'
 
 const TRIVIAL_COMMENT_PATTERNS = [
   { comment: /\/\/\s*return\b/i, code: /^\s*return\b/ },
@@ -41,7 +41,7 @@ function checkLineForContradiction(
 
 export function detectCommentContradiction(file: SourceFile): DriftIssue[] {
   const issues: DriftIssue[] = []
-  const lines = file.getFullText().split('\n')
+  const lines = getFileLines(file)
 
   for (let i = 0; i < lines.length - 1; i++) {
     const commentLine = lines[i].trim()