@eduardbar/drift 1.1.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,8 +28,55 @@ export type {
   DriftConfig,
   RepoQualityScore,
   MaintenanceRiskMetrics,
+  DriftTrustReport,
+  TrustReason,
+  TrustFixPriority,
+  TrustDiffContext,
+  TrustKpiReport,
+  TrustKpiDiagnostic,
+  TrustDiffTrendSummary,
+  TrustScoreStats,
+  MergeRiskLevel,
   DriftPlugin,
   DriftPluginRule,
 } from './types.js'
 export { loadHistory, saveSnapshot } from './snapshot.js'
 export type { SnapshotEntry, SnapshotHistory } from './snapshot.js'
+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/map.ts

@@ -1,12 +1,23 @@
 import { writeFileSync } from 'node:fs'
 import { resolve, relative } from 'node:path'
 import { Project } from 'ts-morph'
+import type { DriftConfig } from './types.js'
+import { detectLayerViolations } from './rules/phase3-arch.js'
+import { RULE_WEIGHTS } from './analyzer.js'
 
 interface LayerNode {
   name: string
   files: Set<string>
 }
 
+interface MapEdge {
+  key: string
+  from: string
+  to: string
+  count: number
+  kind: 'normal' | 'cycle' | 'violation'
+}
+
 function detectLayer(relPath: string): string {
   const normalized = relPath.replace(/\\/g, '/').replace(/^\.\//, '')
   const first = normalized.split('/')[0] || 'root'
@@ -17,7 +28,7 @@ function esc(value: string): string {
   return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
 }
 
-export function generateArchitectureSvg(targetPath: string): string {
+export function generateArchitectureSvg(targetPath: string, config?: DriftConfig): string {
   const project = new Project({
     skipAddingFilesFromTsConfig: true,
     compilerOptions: { allowJs: true, jsx: 1 },
@@ -36,24 +47,65 @@ export function generateArchitectureSvg(targetPath: string): string {
 
   const layers = new Map<string, LayerNode>()
   const edges = new Map<string, number>()
+  const layerAdjacency = new Map<string, Set<string>>()
+  const fileImportGraph = new Map<string, Set<string>>()
 
   for (const file of project.getSourceFiles()) {
-    const rel = relative(targetPath, file.getFilePath()).replace(/\\/g, '/')
+    const filePath = file.getFilePath()
+    const rel = relative(targetPath, filePath).replace(/\\/g, '/')
     const layerName = detectLayer(rel)
     if (!layers.has(layerName)) layers.set(layerName, { name: layerName, files: new Set() })
     layers.get(layerName)!.files.add(rel)
+    if (!fileImportGraph.has(filePath)) fileImportGraph.set(filePath, new Set())
 
     for (const decl of file.getImportDeclarations()) {
       const imported = decl.getModuleSpecifierSourceFile()
       if (!imported) continue
+      fileImportGraph.get(filePath)!.add(imported.getFilePath())
       const importedRel = relative(targetPath, imported.getFilePath()).replace(/\\/g, '/')
       const importedLayer = detectLayer(importedRel)
       if (importedLayer === layerName) continue
       const key = `${layerName}->${importedLayer}`
       edges.set(key, (edges.get(key) ?? 0) + 1)
+      if (!layerAdjacency.has(layerName)) layerAdjacency.set(layerName, new Set())
+      layerAdjacency.get(layerName)!.add(importedLayer)
     }
   }
 
+  const cycleEdges = detectCycleEdges(layerAdjacency)
+  const violationEdges = new Set<string>()
+
+  if (config?.layers && config.layers.length > 0) {
+    const violations = detectLayerViolations(fileImportGraph, config.layers, targetPath, RULE_WEIGHTS)
+    for (const issues of violations.values()) {
+      for (const issue of issues) {
+        const match = issue.message.match(/Layer '([^']+)' must not import from layer '([^']+)'/)
+        if (!match) continue
+        const from = match[1]
+        const to = match[2]
+        violationEdges.add(`${from}->${to}`)
+        if (!layers.has(from)) layers.set(from, { name: from, files: new Set() })
+        if (!layers.has(to)) layers.set(to, { name: to, files: new Set() })
+      }
+    }
+  }
+
+  const edgeList: MapEdge[] = [...edges.entries()].map(([key, count]) => {
+    const [from, to] = key.split('->')
+    const kind = violationEdges.has(key)
+      ? 'violation'
+      : cycleEdges.has(key)
+        ? 'cycle'
+        : 'normal'
+    return { key, from, to, count, kind }
+  })
+
+  for (const key of violationEdges) {
+    if (edges.has(key)) continue
+    const [from, to] = key.split('->')
+    edgeList.push({ key, from, to, count: 1, kind: 'violation' })
+  }
+
   const layerList = [...layers.values()].sort((a, b) => a.name.localeCompare(b.name))
   const width = 960
   const rowHeight = 90
@@ -73,18 +125,23 @@ export function generateArchitectureSvg(targetPath: string): string {
 
   const boxByName = new Map(boxes.map((box) => [box.name, box]))
 
-  const lines = [...edges.entries()].map(([key, count]) => {
-    const [from, to] = key.split('->')
-    const a = boxByName.get(from)
-    const b = boxByName.get(to)
+  const lines = edgeList.map((edge) => {
+    const a = boxByName.get(edge.from)
+    const b = boxByName.get(edge.to)
     if (!a || !b) return ''
     const startX = a.x + boxWidth
     const startY = a.y + boxHeight / 2
     const endX = b.x
     const endY = b.y + boxHeight / 2
+    const stroke = edge.kind === 'violation'
+      ? '#ef4444'
+      : edge.kind === 'cycle'
+        ? '#f59e0b'
+        : '#64748b'
+    const widthPx = edge.kind === 'normal' ? 2 : 3
     return `
-      <line x1="${startX}" y1="${startY}" x2="${endX}" y2="${endY}" stroke="#64748b" stroke-width="2" marker-end="url(#arrow)" />
-      <text x="${(startX + endX) / 2}" y="${(startY + endY) / 2 - 4}" fill="#94a3b8" font-size="11" text-anchor="middle">${count}</text>`
+      <line x1="${startX}" y1="${startY}" x2="${endX}" y2="${endY}" stroke="${stroke}" stroke-width="${widthPx}" marker-end="url(#arrow)" data-edge="${esc(edge.key)}" data-kind="${edge.kind}" />
+      <text x="${(startX + endX) / 2}" y="${(startY + endY) / 2 - 4}" fill="#94a3b8" font-size="11" text-anchor="middle">${edge.count}</text>`
   }).join('')
 
   const nodes = boxes.map((box) => `
@@ -94,6 +151,9 @@ export function generateArchitectureSvg(targetPath: string): string {
       <text x="${box.x + 12}" y="${box.y + 38}" fill="#94a3b8" font-size="11" font-family="monospace">${box.files.size} file(s)</text>
     </g>`).join('')
 
+  const cycleCount = edgeList.filter((edge) => edge.kind === 'cycle').length
+  const violationCount = edgeList.filter((edge) => edge.kind === 'violation').length
+
   return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
   <defs>
     <marker id="arrow" markerWidth="10" markerHeight="10" refX="6" refY="3" orient="auto">
@@ -103,14 +163,56 @@ export function generateArchitectureSvg(targetPath: string): string {
   <rect x="0" y="0" width="${width}" height="${height}" fill="#020617" />
   <text x="28" y="34" fill="#f8fafc" font-size="16" font-family="monospace">drift architecture map</text>
   <text x="28" y="54" fill="#94a3b8" font-size="11" font-family="monospace">Layers inferred from top-level directories</text>
+  <text x="28" y="72" fill="#94a3b8" font-size="11" font-family="monospace">Cycle edges: ${cycleCount} | Layer violations: ${violationCount}</text>
+  <line x1="520" y1="66" x2="560" y2="66" stroke="#f59e0b" stroke-width="3" /><text x="567" y="69" fill="#94a3b8" font-size="11" font-family="monospace">cycle</text>
+  <line x1="630" y1="66" x2="670" y2="66" stroke="#ef4444" stroke-width="3" /><text x="677" y="69" fill="#94a3b8" font-size="11" font-family="monospace">violation</text>
   ${lines}
   ${nodes}
 </svg>`
 }
 
-export function generateArchitectureMap(targetPath: string, outputFile = 'architecture.svg'): string {
+function detectCycleEdges(adjacency: Map<string, Set<string>>): Set<string> {
+  const visited = new Set<string>()
+  const inStack = new Set<string>()
+  const stack: string[] = []
+  const cycleEdges = new Set<string>()
+
+  function dfs(node: string): void {
+    visited.add(node)
+    inStack.add(node)
+    stack.push(node)
+
+    for (const neighbor of adjacency.get(node) ?? []) {
+      if (!visited.has(neighbor)) {
+        dfs(neighbor)
+        continue
+      }
+
+      if (!inStack.has(neighbor)) continue
+
+      const startIndex = stack.indexOf(neighbor)
+      if (startIndex >= 0) {
+        for (let i = startIndex; i < stack.length - 1; i++) {
+          cycleEdges.add(`${stack[i]}->${stack[i + 1]}`)
+        }
+      }
+      cycleEdges.add(`${node}->${neighbor}`)
+    }
+
+    stack.pop()
+    inStack.delete(node)
+  }
+
+  for (const node of adjacency.keys()) {
+    if (!visited.has(node)) dfs(node)
+  }
+
+  return cycleEdges
+}
+
+export function generateArchitectureMap(targetPath: string, outputFile = 'architecture.svg', config?: DriftConfig): string {
   const resolvedTarget = resolve(targetPath)
-  const svg = generateArchitectureSvg(resolvedTarget)
+  const svg = generateArchitectureSvg(resolvedTarget, config)
   const outPath = resolve(outputFile)
   writeFileSync(outPath, svg, 'utf8')
   return outPath