@eduardbar/drift 1.1.0 → 1.2.0

package/.github/workflows/review-pr.yml

@@ -0,0 +1,61 @@
+name: Drift PR Review
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  drift-review:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Generate drift review markdown
+        run: npx @eduardbar/drift review --base "origin/${{ github.base_ref }}" --comment > drift-review.md
+
+      - name: Post or update PR comment (non-fork only)
+        if: github.event.pull_request.head.repo.fork == false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          REPO: ${{ github.repository }}
+        run: |
+          COMMENT_BODY="<!-- drift-review -->"
+          COMMENT_BODY+=$'\n'
+          COMMENT_BODY+="$(cat drift-review.md)"
+
+          EXISTING_ID=$(gh api "repos/$REPO/issues/$PR_NUMBER/comments" --jq '.[] | select(.user.login == "github-actions[bot]") | select(.body | contains("<!-- drift-review -->")) | .id' | sed -n '1p')
+
+          if [ -n "$EXISTING_ID" ]; then
+            gh api -X PATCH "repos/$REPO/issues/comments/$EXISTING_ID" -f "body=$COMMENT_BODY"
+          else
+            gh api -X POST "repos/$REPO/issues/$PR_NUMBER/comments" -f "body=$COMMENT_BODY"
+          fi
+
+      - name: Fallback summary for fork PRs
+        if: github.event.pull_request.head.repo.fork == true
+        run: |
+          {
+            echo "## drift review"
+            echo
+            cat drift-review.md
+          } >> "$GITHUB_STEP_SUMMARY"
+
+      - name: Enforce drift threshold
+        run: npx @eduardbar/drift review --base "origin/${{ github.base_ref }}" --fail-on 5 --comment > /dev/null

package/README.md

@@ -150,7 +150,7 @@ drift review --base origin/main --fail-on 5
 
 ### `drift map [path]`
 
-Generate an `architecture.svg` map with inferred layer dependencies.
+Generate an `architecture.svg` map with inferred layer dependencies. When layer config is present, the SVG also highlights cycle edges and layer violations.
 
 ```bash
 drift map
@@ -162,6 +162,11 @@ drift map ./src --output docs/architecture.svg
 |------|-------------|
 | `--output <file>` | Output path for the SVG file (default: `architecture.svg`) |
 
+Edge legend in SVG:
+- Gray: normal dependency
+- Orange: cycle edge
+- Red: layer violation edge
+
 ---
 
 ### `drift report [path]`
@@ -270,6 +275,7 @@ Auto-fix safe issues with explicit preview/write modes.
 ```bash
 drift fix ./src --preview
 drift fix ./src --write
+drift fix ./src --write --yes
 drift fix ./src --dry-run   # alias of --preview
 ```
 
@@ -278,6 +284,30 @@ drift fix ./src --dry-run   # alias of --preview
 | `--preview` | Preview before/after without writing files |
 | `--write` | Apply fixes to disk |
 | `--dry-run` | Backward-compatible alias for preview mode |
+| `--yes` | Skip interactive confirmation for write mode |
+
+---
+
+### `drift cloud`
+
+Local SaaS foundations backed by `.drift-cloud/store.json`.
+
+```bash
+drift cloud ingest ./src --workspace acme --user u-123 --repo webapp
+drift cloud summary
+drift cloud summary --json
+drift cloud dashboard --output drift-cloud-dashboard.html
+```
+
+**Subcommands:**
+
+| Command | Description |
+|---------|-------------|
+| `drift cloud ingest [path] --workspace <id> --user <id> [--repo <name>] [--store <file>]` | Scans the path and stores one SaaS snapshot |
+| `drift cloud summary [--json] [--store <file>]` | Shows users/workspaces/repos usage and runs per month |
+| `drift cloud dashboard [--output <file>] [--store <file>]` | Generates an HTML dashboard with trends and hotspots |
+
+`drift cloud` ships with a free-until-7,500 strategy and configurable guardrails for the free phase: max runs per workspace per month, max repos per workspace, and retention window.
 
 ---
 
@@ -412,6 +442,14 @@ jobs:
 
 `drift ci` emits `::error` and `::warning` annotations that appear inline in the PR diff and writes a formatted summary to `$GITHUB_STEP_SUMMARY`. Use this when you want visibility beyond a pass/fail exit code.
 
+### Auto PR comment with `drift review`
+
+The repository includes `.github/workflows/review-pr.yml`, which:
+- generates a PR-ready markdown comment from `drift review --comment`
+- updates a single sticky comment (`<!-- drift-review -->`) on non-fork PRs
+- falls back to `$GITHUB_STEP_SUMMARY` for fork PRs
+- enforces a score delta threshold with `--fail-on`
+
 ---
 
 ## drift-ignore

package/dist/cli.js

@@ -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');
 import { analyzeProject, analyzeFile, TrendAnalyzer, BlameAnalyzer } from './analyzer.js';
@@ -19,6 +21,7 @@ import { applyFixes } 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();
 program
     .name('drift')
@@ -140,7 +143,8 @@ program
     .action(async (targetPath, options) => {
     const resolvedPath = resolve(targetPath ?? '.');
     process.stderr.write(`\nBuilding architecture map for ${resolvedPath}...\n`);
-    const out = generateArchitectureMap(resolvedPath, options.output);
+    const config = await loadConfig(resolvedPath);
+    const out = generateArchitectureMap(resolvedPath, options.output, config);
     process.stderr.write(`  Architecture map saved to ${out}\n\n`);
 });
 program
@@ -232,11 +236,33 @@ program
     .option('--preview', 'Preview changes without writing files')
     .option('--write', 'Write fixes to disk')
     .option('--dry-run', 'Show what would change without writing files')
+    .option('-y, --yes', 'Skip interactive confirmation for --write')
     .action(async (targetPath, options) => {
     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: previewMode,
@@ -305,5 +331,74 @@ program
     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, options) => {
+    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) => {
+    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) => {
+    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();
 //# sourceMappingURL=cli.js.map

package/dist/index.d.ts

@@ -6,4 +6,6 @@ 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';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -4,4 +4,5 @@ export { computeDiff } from './diff.js';
 export { generateReview, formatReviewMarkdown } from './review.js';
 export { generateArchitectureMap, generateArchitectureSvg } from './map.js';
 export { loadHistory, saveSnapshot } from './snapshot.js';
+export { DEFAULT_SAAS_POLICY, defaultSaasStorePath, resolveSaasPolicy, ingestSnapshotFromReport, getSaasSummary, generateSaasDashboardHtml, } from './saas.js';
 //# sourceMappingURL=index.js.map

package/dist/map.d.ts

@@ -1,3 +1,4 @@
-export declare function generateArchitectureSvg(targetPath: string): string;
-export declare function generateArchitectureMap(targetPath: string, outputFile?: string): string;
+import type { DriftConfig } from './types.js';
+export declare function generateArchitectureSvg(targetPath: string, config?: DriftConfig): string;
+export declare function generateArchitectureMap(targetPath: string, outputFile?: string, config?: DriftConfig): string;
 //# sourceMappingURL=map.d.ts.map

package/dist/map.js

@@ -1,6 +1,8 @@
 import { writeFileSync } from 'node:fs';
 import { resolve, relative } from 'node:path';
 import { Project } from 'ts-morph';
+import { detectLayerViolations } from './rules/phase3-arch.js';
+import { RULE_WEIGHTS } from './analyzer.js';
 function detectLayer(relPath) {
     const normalized = relPath.replace(/\\/g, '/').replace(/^\.\//, '');
     const first = normalized.split('/')[0] || 'root';
@@ -9,7 +11,7 @@ function detectLayer(relPath) {
 function esc(value) {
     return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
-export function generateArchitectureSvg(targetPath) {
+export function generateArchitectureSvg(targetPath, config) {
     const project = new Project({
         skipAddingFilesFromTsConfig: true,
         compilerOptions: { allowJs: true, jsx: 1 },
@@ -26,24 +28,67 @@ export function generateArchitectureSvg(targetPath) {
     ]);
     const layers = new Map();
     const edges = new Map();
+    const layerAdjacency = new Map();
+    const fileImportGraph = new Map();
     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();
+    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 = [...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;
@@ -60,19 +105,24 @@ export function generateArchitectureSvg(targetPath) {
         };
     });
     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) => `
     <g>
@@ -80,6 +130,8 @@ export function generateArchitectureSvg(targetPath) {
       <text x="${box.x + 12}" y="${box.y + 22}" fill="#e2e8f0" font-size="13" font-family="monospace">${esc(box.name)}</text>
       <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">
@@ -89,13 +141,49 @@ export function generateArchitectureSvg(targetPath) {
   <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, outputFile = 'architecture.svg') {
+function detectCycleEdges(adjacency) {
+    const visited = new Set();
+    const inStack = new Set();
+    const stack = [];
+    const cycleEdges = new Set();
+    function dfs(node) {
+        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, outputFile = 'architecture.svg', config) {
     const resolvedTarget = resolve(targetPath);
-    const svg = generateArchitectureSvg(resolvedTarget);
+    const svg = generateArchitectureSvg(resolvedTarget, config);
     const outPath = resolve(outputFile);
     writeFileSync(outPath, svg, 'utf8');
     return outPath;

package/dist/saas.d.ts

@@ -0,0 +1,83 @@
+import type { DriftReport, DriftConfig } from './types.js';
+export interface SaasPolicy {
+    freeUserThreshold: number;
+    maxRunsPerWorkspacePerMonth: number;
+    maxReposPerWorkspace: number;
+    retentionDays: number;
+}
+export interface SaasUser {
+    id: string;
+    createdAt: string;
+    lastSeenAt: string;
+}
+export interface SaasWorkspace {
+    id: string;
+    createdAt: string;
+    lastSeenAt: string;
+    userIds: string[];
+    repoIds: string[];
+}
+export interface SaasRepo {
+    id: string;
+    workspaceId: string;
+    name: string;
+    createdAt: string;
+    lastSeenAt: string;
+}
+export interface SaasSnapshot {
+    id: string;
+    createdAt: string;
+    scannedAt: string;
+    workspaceId: string;
+    userId: string;
+    repoId: string;
+    repoName: string;
+    targetPath: string;
+    totalScore: number;
+    totalIssues: number;
+    totalFiles: number;
+    summary: {
+        errors: number;
+        warnings: number;
+        infos: number;
+    };
+}
+export interface SaasStore {
+    version: number;
+    policy: SaasPolicy;
+    users: Record<string, SaasUser>;
+    workspaces: Record<string, SaasWorkspace>;
+    repos: Record<string, SaasRepo>;
+    snapshots: SaasSnapshot[];
+}
+export interface SaasSummary {
+    policy: SaasPolicy;
+    usersRegistered: number;
+    workspacesActive: number;
+    reposActive: number;
+    runsPerMonth: Record<string, number>;
+    totalSnapshots: number;
+    phase: 'free' | 'paid';
+    thresholdReached: boolean;
+    freeUsersRemaining: number;
+}
+export interface IngestOptions {
+    workspaceId: string;
+    userId: string;
+    repoName?: string;
+    storeFile?: string;
+    policy?: Partial<SaasPolicy>;
+}
+export declare const DEFAULT_SAAS_POLICY: SaasPolicy;
+export declare function resolveSaasPolicy(policy?: Partial<SaasPolicy> | DriftConfig['saas']): SaasPolicy;
+export declare function defaultSaasStorePath(root?: string): string;
+export declare function ingestSnapshotFromReport(report: DriftReport, options: IngestOptions): SaasSnapshot;
+export declare function getSaasSummary(options?: {
+    storeFile?: string;
+    policy?: Partial<SaasPolicy>;
+}): SaasSummary;
+export declare function generateSaasDashboardHtml(options?: {
+    storeFile?: string;
+    policy?: Partial<SaasPolicy>;
+}): string;
+//# sourceMappingURL=saas.d.ts.map