@eduardbar/drift 1.0.0 → 1.2.0

package/src/cli.ts

@@ -2,8 +2,10 @@
 // drift-ignore-file
 import { Command } from 'commander'
 import { writeFileSync } from 'node:fs'
-import { resolve } from 'node:path'
+import { basename, resolve } from 'node:path'
 import { createRequire } from 'node:module'
+import { createInterface } from 'node:readline/promises'
+import { stdin as input, stdout as output } from 'node:process'
 const require = createRequire(import.meta.url)
 const { version: VERSION } = require('../package.json') as { version: string }
 import { analyzeProject, analyzeFile, TrendAnalyzer, BlameAnalyzer } from './analyzer.js'
@@ -16,6 +18,10 @@ import { generateHtmlReport } from './report.js'
 import { generateBadge } from './badge.js'
 import { emitCIAnnotations, printCISummary } from './ci.js'
 import { applyFixes, type FixResult } from './fix.js'
+import { loadHistory, saveSnapshot, printHistory, printSnapshotDiff } from './snapshot.js'
+import { generateReview } from './review.js'
+import { generateArchitectureMap } from './map.js'
+import { ingestSnapshotFromReport, getSaasSummary, generateSaasDashboardHtml } from './saas.js'
 
 const program = new Command()
 
@@ -117,6 +123,46 @@ program
     }
   })
 
+program
+  .command('review')
+  .description('Review drift against a base ref and output PR markdown')
+  .option('--base <ref>', 'Git base ref to compare against', 'origin/main')
+  .option('--json', 'Output structured review JSON')
+  .option('--comment', 'Output markdown comment body')
+  .option('--fail-on <n>', 'Exit with code 1 if score delta is >= n')
+  .action(async (options: { base: string; json?: boolean; comment?: boolean; failOn?: string }) => {
+    try {
+      const review = await generateReview(resolve('.'), options.base)
+
+      if (options.json) {
+        process.stdout.write(JSON.stringify(review, null, 2) + '\n')
+      } else {
+        process.stdout.write((options.comment ? review.markdown : `${review.summary}\n\n${review.markdown}`) + '\n')
+      }
+
+      const failOn = options.failOn ? Number(options.failOn) : undefined
+      if (typeof failOn === 'number' && !Number.isNaN(failOn) && review.totalDelta >= failOn) {
+        process.exit(1)
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err)
+      process.stderr.write(`\n  Error: ${message}\n\n`)
+      process.exit(1)
+    }
+  })
+
+program
+  .command('map [path]')
+  .description('Generate architecture.svg with simple layer dependencies')
+  .option('-o, --output <file>', 'Output SVG path (default: architecture.svg)', 'architecture.svg')
+  .action(async (targetPath: string | undefined, options: { output: string }) => {
+    const resolvedPath = resolve(targetPath ?? '.')
+    process.stderr.write(`\nBuilding architecture map for ${resolvedPath}...\n`)
+    const config = await loadConfig(resolvedPath)
+    const out = generateArchitectureMap(resolvedPath, options.output, config)
+    process.stderr.write(`  Architecture map saved to ${out}\n\n`)
+  })
+
 program
   .command('report [path]')
   .description('Generate a self-contained HTML report')
@@ -214,14 +260,46 @@ program
   .command('fix [path]')
   .description('Auto-fix safe issues (debug-leftover console.*, catch-swallow)')
   .option('--rule <rule>', 'Fix only a specific rule')
+  .option('--preview', 'Preview changes without writing files')
+  .option('--write', 'Write fixes to disk')
   .option('--dry-run', 'Show what would change without writing files')
-  .action(async (targetPath: string | undefined, options: { rule?: string; dryRun?: boolean }) => {
+  .option('-y, --yes', 'Skip interactive confirmation for --write')
+  .action(async (targetPath: string | undefined, options: { rule?: string; dryRun?: boolean; preview?: boolean; write?: boolean; yes?: boolean }) => {
     const resolvedPath = resolve(targetPath ?? '.')
     const config = await loadConfig(resolvedPath)
+    const previewMode = Boolean(options.preview || options.dryRun)
+    const writeMode = options.write ?? !previewMode
+
+    if (writeMode && !options.yes) {
+      const previewResults = await applyFixes(resolvedPath, config, {
+        rule: options.rule,
+        dryRun: true,
+        preview: true,
+        write: false,
+      })
+
+      if (previewResults.length === 0) {
+        console.log('No fixable issues found.')
+        return
+      }
+
+      const files = new Set(previewResults.map((result) => result.file)).size
+      const prompt = `Apply ${previewResults.length} fix(es) across ${files} file(s)? [y/N] `
+      const rl = createInterface({ input, output })
+      const answer = (await rl.question(prompt)).trim().toLowerCase()
+      rl.close()
+
+      if (answer !== 'y' && answer !== 'yes') {
+        console.log('Aborted. No files were modified.')
+        return
+      }
+    }
 
     const results = await applyFixes(resolvedPath, config, {
       rule: options.rule,
-      dryRun: options.dryRun,
+      dryRun: previewMode,
+      preview: previewMode,
+      write: writeMode,
     })
 
     if (results.length === 0) {
@@ -231,8 +309,8 @@ program
 
     const applied = results.filter(r => r.applied)
 
-    if (options.dryRun) {
-      console.log(`\ndrift fix --dry-run: ${results.length} fixable issues found\n`)
+    if (previewMode) {
+      console.log(`\ndrift fix --preview: ${results.length} fixable issues found\n`)
     } else {
       console.log(`\ndrift fix: ${applied.length} fixes applied\n`)
     }
@@ -248,14 +326,135 @@ program
       const relPath = file.replace(resolvedPath + '/', '').replace(resolvedPath + '\\', '')
       console.log(`  ${relPath}`)
       for (const r of fileResults) {
-        const status = r.applied ? (options.dryRun ? 'would fix' : 'fixed') : 'skipped'
+        const status = r.applied ? (previewMode ? 'would fix' : 'fixed') : 'skipped'
         console.log(`    [${r.rule}] line ${r.line}: ${r.description} — ${status}`)
+        if (r.before || r.after) {
+          console.log(`      before: ${r.before ?? '(empty)'}`)
+          console.log(`      after : ${r.after ?? '(empty)'}`)
+        }
       }
     }
 
-    if (!options.dryRun && applied.length > 0) {
+    if (!previewMode && applied.length > 0) {
       console.log(`\n${applied.length} issue(s) fixed. Re-run drift scan to verify.`)
     }
   })
 
+program
+  .command('snapshot [path]')
+  .description('Record a score snapshot to drift-history.json')
+  .option('-l, --label <label>', 'label for this snapshot (e.g. sprint name, version)')
+  .option('--history', 'show all recorded snapshots')
+  .option('--diff', 'compare current score vs last snapshot')
+  .action(async (
+    targetPath: string | undefined,
+    opts: { label?: string; history?: boolean; diff?: boolean },
+  ) => {
+    const resolvedPath = resolve(targetPath ?? '.')
+
+    if (opts.history) {
+      const history = loadHistory(resolvedPath)
+      printHistory(history)
+      return
+    }
+
+    process.stderr.write(`\nScanning ${resolvedPath}...\n`)
+    const config = await loadConfig(resolvedPath)
+    const files = analyzeProject(resolvedPath, config)
+    process.stderr.write(`  Found ${files.length} TypeScript file(s)\n\n`)
+    const report = buildReport(resolvedPath, files)
+
+    if (opts.diff) {
+      const history = loadHistory(resolvedPath)
+      printSnapshotDiff(history, report.totalScore)
+      return
+    }
+
+    const entry = saveSnapshot(resolvedPath, report, opts.label)
+    const labelStr = entry.label ? ` [${entry.label}]` : ''
+    process.stdout.write(
+      `  Snapshot recorded${labelStr}: score ${entry.score} (${entry.grade}) — ${entry.totalIssues} issues across ${entry.files} files\n`,
+    )
+    process.stdout.write(`  Saved to drift-history.json\n\n`)
+  })
+
+const cloud = program
+  .command('cloud')
+  .description('Local SaaS foundations: ingest, summary, and dashboard')
+
+cloud
+  .command('ingest [path]')
+  .description('Scan path, build report, and store cloud snapshot')
+  .requiredOption('--workspace <id>', 'Workspace id')
+  .requiredOption('--user <id>', 'User id')
+  .option('--repo <name>', 'Repo name (default: basename of scanned path)')
+  .option('--store <file>', 'Store file path (default: .drift-cloud/store.json)')
+  .action(async (targetPath: string | undefined, options: { workspace: string; user: string; repo?: string; store?: string }) => {
+    const resolvedPath = resolve(targetPath ?? '.')
+    process.stderr.write(`\nScanning ${resolvedPath} for cloud ingest...\n`)
+    const config = await loadConfig(resolvedPath)
+    const files = analyzeProject(resolvedPath, config)
+    const report = buildReport(resolvedPath, files)
+
+    const snapshot = ingestSnapshotFromReport(report, {
+      workspaceId: options.workspace,
+      userId: options.user,
+      repoName: options.repo ?? basename(resolvedPath),
+      storeFile: options.store,
+      policy: config?.saas,
+    })
+
+    process.stdout.write(`Ingested snapshot ${snapshot.id}\n`)
+    process.stdout.write(`Workspace: ${snapshot.workspaceId}  Repo: ${snapshot.repoName}\n`)
+    process.stdout.write(`Score: ${snapshot.totalScore}/100  Issues: ${snapshot.totalIssues}\n\n`)
+  })
+
+cloud
+  .command('summary')
+  .description('Show SaaS usage metrics and free threshold status')
+  .option('--json', 'Output raw JSON summary')
+  .option('--store <file>', 'Store file path (default: .drift-cloud/store.json)')
+  .action((options: { json?: boolean; store?: string }) => {
+    const summary = getSaasSummary({ storeFile: options.store })
+
+    if (options.json) {
+      process.stdout.write(JSON.stringify(summary, null, 2) + '\n')
+      return
+    }
+
+    process.stdout.write('\n')
+    process.stdout.write(`Phase: ${summary.phase.toUpperCase()}\n`)
+    process.stdout.write(`Users registered: ${summary.usersRegistered}\n`)
+    process.stdout.write(`Active workspaces (30d): ${summary.workspacesActive}\n`)
+    process.stdout.write(`Active repos (30d): ${summary.reposActive}\n`)
+    process.stdout.write(`Total snapshots: ${summary.totalSnapshots}\n`)
+    process.stdout.write(`Free user threshold: ${summary.policy.freeUserThreshold}\n`)
+    process.stdout.write(`Threshold reached: ${summary.thresholdReached ? 'yes' : 'no'}\n`)
+    process.stdout.write(`Free users remaining: ${summary.freeUsersRemaining}\n`)
+    process.stdout.write('Runs per month:\n')
+
+    const monthly = Object.entries(summary.runsPerMonth).sort(([a], [b]) => a.localeCompare(b))
+    if (monthly.length === 0) {
+      process.stdout.write('  - none\n\n')
+      return
+    }
+
+    for (const [month, runs] of monthly) {
+      process.stdout.write(`  - ${month}: ${runs}\n`)
+    }
+    process.stdout.write('\n')
+  })
+
+cloud
+  .command('dashboard')
+  .description('Generate an HTML dashboard with trends and hotspots')
+  .option('-o, --output <file>', 'Output HTML file', 'drift-cloud-dashboard.html')
+  .option('--store <file>', 'Store file path (default: .drift-cloud/store.json)')
+  .action((options: { output: string; store?: string }) => {
+    const html = generateSaasDashboardHtml({ storeFile: options.store })
+    const outPath = resolve(options.output)
+    writeFileSync(outPath, html, 'utf8')
+    process.stdout.write(`Dashboard saved to ${outPath}\n`)
+  })
+
 program.parse()

package/src/diff.ts

@@ -7,6 +7,40 @@ import type { DriftReport, DriftDiff, FileDiff, DriftIssue } from './types.js'
  * A "new" issue exists in `current` but not in `base`.
  * A "resolved" issue exists in `base` but not in `current`.
  */
+function computeFileDiff(
+  filePath: string,
+  baseFile: { score: number; issues: DriftIssue[] } | undefined,
+  currentFile: { score: number; issues: DriftIssue[] } | undefined,
+): FileDiff | null {
+  const scoreBefore = baseFile?.score ?? 0
+  const scoreAfter = currentFile?.score ?? 0
+  const scoreDelta = scoreAfter - scoreBefore
+
+  const baseIssues = baseFile?.issues ?? []
+  const currentIssues = currentFile?.issues ?? []
+
+  const issueKey = (i: DriftIssue) => `${i.rule}:${i.line}:${i.column}`
+
+  const baseKeys = new Set(baseIssues.map(issueKey))
+  const currentKeys = new Set(currentIssues.map(issueKey))
+
+  const newIssues = currentIssues.filter(i => !baseKeys.has(issueKey(i)))
+  const resolvedIssues = baseIssues.filter(i => !currentKeys.has(issueKey(i)))
+
+  if (scoreDelta !== 0 || newIssues.length > 0 || resolvedIssues.length > 0) {
+    return {
+      path: filePath,
+      scoreBefore,
+      scoreAfter,
+      scoreDelta,
+      newIssues,
+      resolvedIssues,
+    }
+  }
+
+  return null
+}
+
 export function computeDiff(
   base: DriftReport,
   current: DriftReport,
@@ -14,11 +48,9 @@ export function computeDiff(
 ): DriftDiff {
   const fileDiffs: FileDiff[] = []
 
-  // Build a map of base files by path for O(1) lookup
   const baseByPath = new Map(base.files.map(f => [f.path, f]))
   const currentByPath = new Map(current.files.map(f => [f.path, f]))
 
-  // All unique paths across both reports
   const allPaths = new Set([
     ...base.files.map(f => f.path),
     ...current.files.map(f => f.path),
@@ -28,36 +60,10 @@ export function computeDiff(
     const baseFile = baseByPath.get(filePath)
     const currentFile = currentByPath.get(filePath)
 
-    const scoreBefore = baseFile?.score ?? 0
-    const scoreAfter = currentFile?.score ?? 0
-    const scoreDelta = scoreAfter - scoreBefore
-
-    const baseIssues = baseFile?.issues ?? []
-    const currentIssues = currentFile?.issues ?? []
-
-    // Issue identity key: rule + line + column
-    const issueKey = (i: DriftIssue) => `${i.rule}:${i.line}:${i.column}`
-
-    const baseKeys = new Set(baseIssues.map(issueKey))
-    const currentKeys = new Set(currentIssues.map(issueKey))
-
-    const newIssues = currentIssues.filter(i => !baseKeys.has(issueKey(i)))
-    const resolvedIssues = baseIssues.filter(i => !currentKeys.has(issueKey(i)))
-
-    // Only include files that have actual changes
-    if (scoreDelta !== 0 || newIssues.length > 0 || resolvedIssues.length > 0) {
-      fileDiffs.push({
-        path: filePath,
-        scoreBefore,
-        scoreAfter,
-        scoreDelta,
-        newIssues,
-        resolvedIssues,
-      })
-    }
+    const diff = computeFileDiff(filePath, baseFile, currentFile)
+    if (diff) fileDiffs.push(diff)
   }
 
-  // Sort: most regressed first, then most improved last
   fileDiffs.sort((a, b) => b.scoreDelta - a.scoreDelta)
 
   return {

package/src/fix.ts

@@ -1,7 +1,7 @@
 import { readFileSync, writeFileSync, statSync } from 'node:fs'
 import { resolve } from 'node:path'
 import { analyzeProject, analyzeFile } from './analyzer.js'
-import type { DriftIssue, DriftConfig } from './types.js'
+import type { DriftIssue, DriftConfig, FileReport } from './types.js'
 import { Project } from 'ts-morph'
 
 export interface FixResult {
@@ -10,6 +10,8 @@ export interface FixResult {
   line: number
   description: string
   applied: boolean
+  before?: string
+  after?: string
 }
 
 const FIXABLE_RULES = new Set(['debug-leftover', 'catch-swallow'])
@@ -73,15 +75,84 @@ function applyFixToLines(
   return null
 }
 
+function collectFixableIssues(
+  fileReports: FileReport[],
+  options?: { rule?: string }
+): Map<string, DriftIssue[]> {
+  const fixableByFile = new Map<string, DriftIssue[]>()
+
+  for (const report of fileReports) {
+    const fixableIssues = report.issues.filter(issue => {
+      if (!isFixable(issue)) return false
+      if (options?.rule && issue.rule !== options.rule) return false
+      return true
+    })
+
+    if (fixableIssues.length > 0) {
+      fixableByFile.set(report.path, fixableIssues)
+    }
+  }
+
+  return fixableByFile
+}
+
+function processFile(
+  filePath: string,
+  issues: DriftIssue[],
+  dryRun: boolean
+): FixResult[] {
+  const content = readFileSync(filePath, 'utf8')
+  let lines = content.split('\n')
+  const results: FixResult[] = []
+
+  const sortedIssues = [...issues].sort((a, b) => b.line - a.line)
+
+  for (const issue of sortedIssues) {
+    const before = lines[issue.line - 1]?.trim() ?? ''
+    const fixResult = applyFixToLines(lines, issue)
+
+    if (fixResult) {
+      const after = fixResult.newLines[issue.line - 1]?.trim() ?? ''
+      results.push({
+        file: filePath,
+        rule: issue.rule,
+        line: issue.line,
+        description: fixResult.description,
+        applied: true,
+        before,
+        after,
+      })
+      lines = fixResult.newLines
+    } else {
+      results.push({
+        file: filePath,
+        rule: issue.rule,
+        line: issue.line,
+        description: 'no fix available',
+        applied: false,
+      })
+    }
+  }
+
+  if (!dryRun) {
+    writeFileSync(filePath, lines.join('\n'), 'utf8')
+  }
+
+  return results
+}
+
 export async function applyFixes(
   targetPath: string,
   config?: DriftConfig,
-  options?: { rule?: string; dryRun?: boolean }
+  options?: { rule?: string; dryRun?: boolean; write?: boolean; preview?: boolean }
 ): Promise<FixResult[]> {
   const resolvedPath = resolve(targetPath)
-  const dryRun = options?.dryRun ?? false
+  const dryRun = options?.write
+    ? false
+    : options?.preview || options?.dryRun
+      ? true
+      : false
 
-  // Determine if target is a file or directory
   let fileReports
   const stat = statSync(resolvedPath)
 
@@ -96,58 +167,11 @@ export async function applyFixes(
     fileReports = analyzeProject(resolvedPath, config)
   }
 
-  // Collect fixable issues, optionally filtered by rule
-  const fixableByFile = new Map<string, DriftIssue[]>()
-
-  for (const report of fileReports) {
-    const fixableIssues = report.issues.filter(issue => {
-      if (!isFixable(issue)) return false
-      if (options?.rule && issue.rule !== options.rule) return false
-      return true
-    })
-
-    if (fixableIssues.length > 0) {
-      fixableByFile.set(report.path, fixableIssues)
-    }
-  }
-
+  const fixableByFile = collectFixableIssues(fileReports, options)
   const results: FixResult[] = []
 
   for (const [filePath, issues] of fixableByFile) {
-    const content = readFileSync(filePath, 'utf8')
-    let lines = content.split('\n')
-
-    // Sort issues by line descending to avoid line number drift after fixes
-    const sortedIssues = [...issues].sort((a, b) => b.line - a.line)
-
-    // Track line offset caused by deletions (debug-leftover removes lines)
-    // We process top-to-bottom after sorting descending, so no offset needed per issue
-    for (const issue of sortedIssues) {
-      const fixResult = applyFixToLines(lines, issue)
-
-      if (fixResult) {
-        results.push({
-          file: filePath,
-          rule: issue.rule,
-          line: issue.line,
-          description: fixResult.description,
-          applied: true,
-        })
-        lines = fixResult.newLines
-      } else {
-        results.push({
-          file: filePath,
-          rule: issue.rule,
-          line: issue.line,
-          description: 'no fix available',
-          applied: false,
-        })
-      }
-    }
-
-    if (!dryRun) {
-      writeFileSync(filePath, lines.join('\n'), 'utf8')
-    }
+    results.push(...processFile(filePath, issues, dryRun))
   }
 
   return results

package/src/git/trend.ts

@@ -1,5 +1,6 @@
-import type { SourceFile } from 'ts-morph'
-import type { FileReport, DriftConfig, TrendDataPoint, DriftTrendReport, BlameAttribution } from '../types.js'
+// drift-ignore-file
+
+import type { FileReport, DriftConfig, TrendDataPoint, DriftTrendReport } from '../types.js'
 import { assertGitRepo, analyzeHistoricalCommits } from './helpers.js'
 import { buildReport } from '../reporter.js'
 

package/src/git.ts

@@ -13,22 +13,23 @@ import { randomUUID } from 'node:crypto'
  *
  * Throws if the directory is not a git repo or the ref is invalid.
  */
-export function extractFilesAtRef(projectPath: string, ref: string): string {
-  // Verify git repo
+function verifyGitRepo(projectPath: string): void {
   try {
     execSync('git rev-parse --git-dir', { cwd: projectPath, stdio: 'pipe' })
   } catch {
     throw new Error(`Not a git repository: ${projectPath}`)
   }
+}
 
-  // Verify ref exists
+function verifyRefExists(projectPath: string, ref: string): void {
   try {
     execSync(`git rev-parse --verify ${ref}`, { cwd: projectPath, stdio: 'pipe' })
   } catch {
     throw new Error(`Invalid git ref: '${ref}'. Run 'git log --oneline' to see available commits.`)
   }
+}
 
-  // List all .ts files tracked at this ref (excluding .d.ts)
+function listTsFilesAtRef(projectPath: string, ref: string): string[] {
   let fileList: string
   try {
     fileList = execSync(
@@ -39,36 +40,44 @@ export function extractFilesAtRef(projectPath: string, ref: string): string {
     throw new Error(`Failed to list files at ref '${ref}'`)
   }
 
-  const tsFiles = fileList
+  return fileList
     .split('\n')
     .map(f => f.trim())
     .filter(f => (f.endsWith('.ts') || f.endsWith('.tsx') || f.endsWith('.js') || f.endsWith('.jsx')) && !f.endsWith('.d.ts'))
+}
+
+function extractFile(projectPath: string, ref: string, filePath: string, tempDir: string): void {
+  let content: string
+  try {
+    content = execSync(
+      `git show ${ref}:${filePath}`,
+      { cwd: projectPath, encoding: 'utf-8', stdio: 'pipe' }
+    )
+  } catch {
+    return
+  }
+
+  const destPath = join(tempDir, filePath.split('/').join(sep))
+  const destDir = destPath.substring(0, destPath.lastIndexOf(sep))
+  mkdirSync(destDir, { recursive: true })
+  writeFileSync(destPath, content, 'utf-8')
+}
+
+export function extractFilesAtRef(projectPath: string, ref: string): string {
+  verifyGitRepo(projectPath)
+  verifyRefExists(projectPath, ref)
+
+  const tsFiles = listTsFilesAtRef(projectPath, ref)
 
   if (tsFiles.length === 0) {
     throw new Error(`No TypeScript files found at ref '${ref}'`)
   }
 
-  // Create temp directory
   const tempDir = join(tmpdir(), `drift-diff-${randomUUID()}`)
   mkdirSync(tempDir, { recursive: true })
 
-  // Extract each file
   for (const filePath of tsFiles) {
-    let content: string
-    try {
-      content = execSync(
-        `git show ${ref}:${filePath}`,
-        { cwd: projectPath, encoding: 'utf-8', stdio: 'pipe' }
-      )
-    } catch {
-      // File may not exist at this ref — skip
-      continue
-    }
-
-    const destPath = join(tempDir, filePath.split('/').join(sep))
-    const destDir = destPath.substring(0, destPath.lastIndexOf(sep))
-    mkdirSync(destDir, { recursive: true })
-    writeFileSync(destPath, content, 'utf-8')
+    extractFile(projectPath, ref, filePath, tempDir)
   }
 
   return tempDir

package/src/index.ts

@@ -1,4 +1,34 @@
 export { analyzeProject, analyzeFile, RULE_WEIGHTS } from './analyzer.js'
 export { buildReport, formatMarkdown } from './reporter.js'
 export { computeDiff } from './diff.js'
-export type { DriftReport, FileReport, DriftIssue, DriftDiff, FileDiff, DriftConfig } from './types.js'
+export { generateReview, formatReviewMarkdown } from './review.js'
+export { generateArchitectureMap, generateArchitectureSvg } from './map.js'
+export type {
+  DriftReport,
+  FileReport,
+  DriftIssue,
+  DriftDiff,
+  FileDiff,
+  DriftConfig,
+  RepoQualityScore,
+  MaintenanceRiskMetrics,
+  DriftPlugin,
+  DriftPluginRule,
+} from './types.js'
+export { loadHistory, saveSnapshot } from './snapshot.js'
+export type { SnapshotEntry, SnapshotHistory } from './snapshot.js'
+export {
+  DEFAULT_SAAS_POLICY,
+  defaultSaasStorePath,
+  resolveSaasPolicy,
+  ingestSnapshotFromReport,
+  getSaasSummary,
+  generateSaasDashboardHtml,
+} from './saas.js'
+export type {
+  SaasPolicy,
+  SaasStore,
+  SaasSummary,
+  SaasSnapshot,
+  IngestOptions,
+} from './saas.js'