@eduardbar/drift 1.2.0 → 1.4.0

package/dist/saas.js

@@ -1,321 +1,8 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-const STORE_VERSION = 1;
-const ACTIVE_WINDOW_DAYS = 30;
-export const DEFAULT_SAAS_POLICY = {
-    freeUserThreshold: 7500,
-    maxRunsPerWorkspacePerMonth: 500,
-    maxReposPerWorkspace: 20,
-    retentionDays: 90,
-};
-export function resolveSaasPolicy(policy) {
-    return {
-        ...DEFAULT_SAAS_POLICY,
-        ...(policy ?? {}),
-    };
-}
-export function defaultSaasStorePath(root = '.') {
-    return resolve(root, '.drift-cloud', 'store.json');
-}
-function ensureStoreFile(storeFile, policy) {
-    const dir = dirname(storeFile);
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    if (!existsSync(storeFile)) {
-        const initial = createEmptyStore(policy);
-        writeFileSync(storeFile, JSON.stringify(initial, null, 2), 'utf8');
-    }
-}
-function createEmptyStore(policy) {
-    return {
-        version: STORE_VERSION,
-        policy: resolveSaasPolicy(policy),
-        users: {},
-        workspaces: {},
-        repos: {},
-        snapshots: [],
-    };
-}
-function monthKey(isoDate) {
-    const date = new Date(isoDate);
-    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
-    return `${date.getUTCFullYear()}-${month}`;
-}
-function daysAgo(days) {
-    const now = Date.now();
-    return now - days * 24 * 60 * 60 * 1000;
-}
-function applyRetention(store) {
-    const cutoff = daysAgo(store.policy.retentionDays);
-    store.snapshots = store.snapshots.filter((snapshot) => {
-        return new Date(snapshot.createdAt).getTime() >= cutoff;
-    });
-}
-function saveStore(storeFile, store) {
-    writeFileSync(storeFile, JSON.stringify(store, null, 2), 'utf8');
-}
-function loadStoreInternal(storeFile, policy) {
-    ensureStoreFile(storeFile, policy);
-    const raw = readFileSync(storeFile, 'utf8');
-    const parsed = JSON.parse(raw);
-    const merged = createEmptyStore(parsed.policy);
-    merged.version = parsed.version ?? STORE_VERSION;
-    merged.users = parsed.users ?? {};
-    merged.workspaces = parsed.workspaces ?? {};
-    merged.repos = parsed.repos ?? {};
-    merged.snapshots = parsed.snapshots ?? [];
-    merged.policy = resolveSaasPolicy({ ...merged.policy, ...policy });
-    applyRetention(merged);
-    return merged;
-}
-function isWorkspaceActive(workspace) {
-    return new Date(workspace.lastSeenAt).getTime() >= daysAgo(ACTIVE_WINDOW_DAYS);
-}
-function isRepoActive(repo) {
-    return new Date(repo.lastSeenAt).getTime() >= daysAgo(ACTIVE_WINDOW_DAYS);
-}
-function assertGuardrails(store, options, nowIso) {
-    const usersRegistered = Object.keys(store.users).length;
-    const isFreePhase = usersRegistered < store.policy.freeUserThreshold;
-    if (!isFreePhase)
-        return;
-    if (!store.users[options.userId] && usersRegistered + 1 > store.policy.freeUserThreshold) {
-        throw new Error(`Free threshold reached (${store.policy.freeUserThreshold} users).`);
-    }
-    const workspace = store.workspaces[options.workspaceId];
-    const repoName = options.repoName ?? 'default';
-    const repoId = `${options.workspaceId}:${repoName}`;
-    const repoExists = Boolean(store.repos[repoId]);
-    const repoCount = workspace?.repoIds.length ?? 0;
-    if (!repoExists && repoCount >= store.policy.maxReposPerWorkspace) {
-        throw new Error(`Workspace '${options.workspaceId}' reached max repos (${store.policy.maxReposPerWorkspace}).`);
-    }
-    const currentMonth = monthKey(nowIso);
-    const runsThisMonth = store.snapshots.filter((snapshot) => {
-        return snapshot.workspaceId === options.workspaceId && monthKey(snapshot.createdAt) === currentMonth;
-    }).length;
-    if (runsThisMonth >= store.policy.maxRunsPerWorkspacePerMonth) {
-        throw new Error(`Workspace '${options.workspaceId}' reached max monthly runs (${store.policy.maxRunsPerWorkspacePerMonth}).`);
-    }
-}
-export function ingestSnapshotFromReport(report, options) {
-    const storeFile = resolve(options.storeFile ?? defaultSaasStorePath());
-    const store = loadStoreInternal(storeFile, options.policy);
-    const nowIso = new Date().toISOString();
-    assertGuardrails(store, options, nowIso);
-    const user = store.users[options.userId];
-    if (user) {
-        user.lastSeenAt = nowIso;
-    }
-    else {
-        store.users[options.userId] = {
-            id: options.userId,
-            createdAt: nowIso,
-            lastSeenAt: nowIso,
-        };
-    }
-    const workspace = store.workspaces[options.workspaceId];
-    if (workspace) {
-        workspace.lastSeenAt = nowIso;
-        if (!workspace.userIds.includes(options.userId))
-            workspace.userIds.push(options.userId);
-    }
-    else {
-        store.workspaces[options.workspaceId] = {
-            id: options.workspaceId,
-            createdAt: nowIso,
-            lastSeenAt: nowIso,
-            userIds: [options.userId],
-            repoIds: [],
-        };
-    }
-    const repoName = options.repoName ?? 'default';
-    const repoId = `${options.workspaceId}:${repoName}`;
-    const repo = store.repos[repoId];
-    if (repo) {
-        repo.lastSeenAt = nowIso;
-    }
-    else {
-        store.repos[repoId] = {
-            id: repoId,
-            workspaceId: options.workspaceId,
-            name: repoName,
-            createdAt: nowIso,
-            lastSeenAt: nowIso,
-        };
-        const ws = store.workspaces[options.workspaceId];
-        if (!ws.repoIds.includes(repoId))
-            ws.repoIds.push(repoId);
-    }
-    const snapshot = {
-        id: `${Date.now()}-${Math.random().toString(16).slice(2, 10)}`,
-        createdAt: nowIso,
-        scannedAt: report.scannedAt,
-        workspaceId: options.workspaceId,
-        userId: options.userId,
-        repoId,
-        repoName,
-        targetPath: report.targetPath,
-        totalScore: report.totalScore,
-        totalIssues: report.totalIssues,
-        totalFiles: report.totalFiles,
-        summary: {
-            errors: report.summary.errors,
-            warnings: report.summary.warnings,
-            infos: report.summary.infos,
-        },
-    };
-    store.snapshots.push(snapshot);
-    applyRetention(store);
-    saveStore(storeFile, store);
-    return snapshot;
-}
-export function getSaasSummary(options) {
-    const storeFile = resolve(options?.storeFile ?? defaultSaasStorePath());
-    const store = loadStoreInternal(storeFile, options?.policy);
-    saveStore(storeFile, store);
-    const usersRegistered = Object.keys(store.users).length;
-    const workspacesActive = Object.values(store.workspaces).filter(isWorkspaceActive).length;
-    const reposActive = Object.values(store.repos).filter(isRepoActive).length;
-    const runsPerMonth = {};
-    for (const snapshot of store.snapshots) {
-        const key = monthKey(snapshot.createdAt);
-        runsPerMonth[key] = (runsPerMonth[key] ?? 0) + 1;
-    }
-    const thresholdReached = usersRegistered >= store.policy.freeUserThreshold;
-    return {
-        policy: store.policy,
-        usersRegistered,
-        workspacesActive,
-        reposActive,
-        runsPerMonth,
-        totalSnapshots: store.snapshots.length,
-        phase: thresholdReached ? 'paid' : 'free',
-        thresholdReached,
-        freeUsersRemaining: Math.max(0, store.policy.freeUserThreshold - usersRegistered),
-    };
-}
-function escapeHtml(value) {
-    return value
-        .replaceAll('&', '&amp;')
-        .replaceAll('<', '&lt;')
-        .replaceAll('>', '&gt;')
-        .replaceAll('"', '&quot;')
-        .replaceAll("'", '&#39;');
-}
-export function generateSaasDashboardHtml(options) {
-    const storeFile = resolve(options?.storeFile ?? defaultSaasStorePath());
-    const store = loadStoreInternal(storeFile, options?.policy);
-    const summary = getSaasSummary(options);
-    const workspaceStats = Object.values(store.workspaces)
-        .map((workspace) => {
-        const snapshots = store.snapshots.filter((snapshot) => snapshot.workspaceId === workspace.id);
-        const runs = snapshots.length;
-        const avgScore = runs === 0
-            ? 0
-            : Math.round(snapshots.reduce((sum, snapshot) => sum + snapshot.totalScore, 0) / runs);
-        const lastRun = snapshots.sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0]?.createdAt ?? 'n/a';
-        return {
-            id: workspace.id,
-            runs,
-            avgScore,
-            lastRun,
-        };
-    })
-        .sort((a, b) => b.avgScore - a.avgScore);
-    const repoStats = Object.values(store.repos)
-        .map((repo) => {
-        const snapshots = store.snapshots.filter((snapshot) => snapshot.repoId === repo.id);
-        const runs = snapshots.length;
-        const avgScore = runs === 0
-            ? 0
-            : Math.round(snapshots.reduce((sum, snapshot) => sum + snapshot.totalScore, 0) / runs);
-        return {
-            workspaceId: repo.workspaceId,
-            name: repo.name,
-            runs,
-            avgScore,
-        };
-    })
-        .sort((a, b) => b.avgScore - a.avgScore)
-        .slice(0, 15);
-    const runsRows = Object.entries(summary.runsPerMonth)
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([month, count]) => {
-        const width = Math.max(8, count * 8);
-        return `<tr><td>${escapeHtml(month)}</td><td>${count}</td><td><div class="bar" style="width:${width}px"></div></td></tr>`;
-    })
-        .join('');
-    const workspaceRows = workspaceStats
-        .map((workspace) => `<tr><td>${escapeHtml(workspace.id)}</td><td>${workspace.runs}</td><td>${workspace.avgScore}</td><td>${escapeHtml(workspace.lastRun)}</td></tr>`)
-        .join('');
-    const repoRows = repoStats
-        .map((repo) => `<tr><td>${escapeHtml(repo.workspaceId)}</td><td>${escapeHtml(repo.name)}</td><td>${repo.runs}</td><td>${repo.avgScore}</td></tr>`)
-        .join('');
-    return `<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>drift cloud dashboard</title>
-  <style>
-    :root { color-scheme: light; }
-    body { margin: 0; font-family: "Segoe UI", Arial, sans-serif; background: #f4f7fb; color: #0f172a; }
-    main { max-width: 980px; margin: 0 auto; padding: 24px; }
-    h1 { margin: 0 0 6px; }
-    p.meta { margin: 0 0 20px; color: #475569; }
-    .cards { display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 12px; margin-bottom: 18px; }
-    .card { background: #ffffff; border-radius: 10px; padding: 14px; border: 1px solid #dbe3ef; }
-    .card .label { font-size: 12px; color: #64748b; text-transform: uppercase; letter-spacing: 0.08em; }
-    .card .value { font-size: 26px; font-weight: 700; margin-top: 4px; }
-    table { width: 100%; border-collapse: collapse; margin-top: 10px; background: #ffffff; border: 1px solid #dbe3ef; border-radius: 10px; overflow: hidden; }
-    th, td { padding: 10px; border-bottom: 1px solid #e2e8f0; text-align: left; font-size: 14px; }
-    th { background: #eef2f9; }
-    .section { margin-top: 18px; }
-    .bar { height: 10px; background: linear-gradient(90deg, #0ea5e9, #22c55e); border-radius: 999px; }
-    .pill { display: inline-block; border-radius: 999px; padding: 4px 10px; font-size: 12px; font-weight: 600; }
-    .pill.free { background: #dcfce7; color: #166534; }
-    .pill.paid { background: #fee2e2; color: #991b1b; }
-  </style>
-</head>
-<body>
-  <main>
-    <h1>drift cloud dashboard</h1>
-    <p class="meta">Store: ${escapeHtml(storeFile)}</p>
-    <div class="cards">
-      <div class="card"><div class="label">Plan Phase</div><div class="value"><span class="pill ${summary.phase}">${summary.phase.toUpperCase()}</span></div></div>
-      <div class="card"><div class="label">Users</div><div class="value">${summary.usersRegistered}</div></div>
-      <div class="card"><div class="label">Active Workspaces</div><div class="value">${summary.workspacesActive}</div></div>
-      <div class="card"><div class="label">Active Repos</div><div class="value">${summary.reposActive}</div></div>
-      <div class="card"><div class="label">Snapshots</div><div class="value">${summary.totalSnapshots}</div></div>
-      <div class="card"><div class="label">Free Seats Left</div><div class="value">${summary.freeUsersRemaining}</div></div>
-    </div>
-
-    <section class="section">
-      <h2>Runs Per Month</h2>
-      <table>
-        <thead><tr><th>Month</th><th>Runs</th><th>Trend</th></tr></thead>
-        <tbody>${runsRows || '<tr><td colspan="3">No runs yet</td></tr>'}</tbody>
-      </table>
-    </section>
-
-    <section class="section">
-      <h2>Workspace Hotspots</h2>
-      <table>
-        <thead><tr><th>Workspace</th><th>Runs</th><th>Avg Score</th><th>Last Run</th></tr></thead>
-        <tbody>${workspaceRows || '<tr><td colspan="4">No workspace data</td></tr>'}</tbody>
-      </table>
-    </section>
-
-    <section class="section">
-      <h2>Repo Hotspots</h2>
-      <table>
-        <thead><tr><th>Workspace</th><th>Repo</th><th>Runs</th><th>Avg Score</th></tr></thead>
-        <tbody>${repoRows || '<tr><td colspan="4">No repo data</td></tr>'}</tbody>
-      </table>
-    </section>
-  </main>
-</body>
-</html>`;
-}
+export { DEFAULT_SAAS_POLICY } from './saas/constants.js';
+export { SaasActorRequiredError, SaasPermissionError } from './saas/errors.js';
+export { resolveSaasPolicy, } from './saas/helpers.js';
+export { defaultSaasStorePath, getRequiredRoleForOperation, assertSaasPermission, getSaasEffectiveLimits, getOrganizationEffectiveLimits, } from './saas/store.js';
+export { ingestSnapshotFromReport } from './saas/ingest.js';
+export { changeOrganizationPlan, listOrganizationPlanChanges, getOrganizationUsageSnapshot, } from './saas/organization.js';
+export { listSaasSnapshots, getSaasSummary, generateSaasDashboardHtml, } from './saas/dashboard.js';
 //# sourceMappingURL=saas.js.map

package/dist/sarif.d.ts

@@ -0,0 +1,74 @@
+import type { DriftIssue, DriftReport } from './types.js';
+import type { DriftDiff } from './types.js';
+export type SarifLevel = 'error' | 'warning' | 'note';
+export interface DriftSarifRule {
+    id: string;
+    name?: string;
+    shortDescription?: {
+        text: string;
+    };
+    defaultConfiguration?: {
+        level: SarifLevel;
+    };
+    properties?: {
+        weight?: number;
+    };
+}
+export interface DriftSarifResult {
+    ruleId: string;
+    level: SarifLevel;
+    message: {
+        text: string;
+    };
+    locations: Array<{
+        physicalLocation: {
+            artifactLocation: {
+                uri: string;
+            };
+            region: {
+                startLine: number;
+                startColumn: number;
+            };
+        };
+    }>;
+    properties?: {
+        weight?: number;
+        fileScore?: number;
+        driftSeverity: DriftIssue['severity'];
+        baseRef?: string;
+        scoreBefore?: number;
+        scoreAfter?: number;
+        scoreDelta?: number;
+        changeType?: 'new-issue';
+    };
+}
+export interface DriftSarifRun {
+    tool: {
+        driver: {
+            name: string;
+            version: string;
+            informationUri: string;
+            rules: DriftSarifRule[];
+        };
+    };
+    results: DriftSarifResult[];
+    properties: {
+        scannedAt: string;
+        targetPath: string;
+        totalIssues: number;
+        totalScore: number;
+        totalFiles: number;
+        baseRef?: string;
+        totalDelta?: number;
+        newIssuesCount?: number;
+        resolvedIssuesCount?: number;
+    };
+}
+export interface DriftSarifLog {
+    $schema: string;
+    version: '2.1.0';
+    runs: DriftSarifRun[];
+}
+export declare function toSarif(report: DriftReport): DriftSarifLog;
+export declare function diffToSarif(diff: DriftDiff): DriftSarifLog;
+//# sourceMappingURL=sarif.d.ts.map

package/dist/sarif.js

@@ -0,0 +1,122 @@
+import { createRequire } from 'node:module';
+import { RULE_WEIGHTS } from './analyzer.js';
+const require = createRequire(import.meta.url);
+const { version: VERSION } = require('../package.json');
+const HTTPS_SCHEME = 'https:';
+const URL_SEPARATOR = '//';
+const SARIF_SCHEMA_HOST_AND_PATH = 'json.schemastore.org/sarif-2.1.0.json';
+const DRIFT_INFORMATION_HOST_AND_PATH = 'github.com/eduardbar/drift';
+const SARIF_SCHEMA_URL = `${HTTPS_SCHEME}${URL_SEPARATOR}${SARIF_SCHEMA_HOST_AND_PATH}`;
+const DRIFT_INFORMATION_URI = `${HTTPS_SCHEME}${URL_SEPARATOR}${DRIFT_INFORMATION_HOST_AND_PATH}`;
+function mapSeverityToSarifLevel(severity) {
+    switch (severity) {
+        case 'error':
+            return 'error';
+        case 'warning':
+            return 'warning';
+        default:
+            return 'note';
+    }
+}
+function normalizeArtifactUri(filePath) {
+    return filePath.replaceAll('\\', '/');
+}
+function toSarifResult(filePath, fileScore, issue, extraProperties) {
+    const line = Math.max(issue.line, 1);
+    const column = Math.max(issue.column, 1);
+    const weight = RULE_WEIGHTS[issue.rule]?.weight;
+    return {
+        ruleId: issue.rule,
+        level: mapSeverityToSarifLevel(issue.severity),
+        message: {
+            text: issue.message,
+        },
+        locations: [{
+                physicalLocation: {
+                    artifactLocation: {
+                        uri: normalizeArtifactUri(filePath),
+                    },
+                    region: {
+                        startLine: line,
+                        startColumn: column,
+                    },
+                },
+            }],
+        properties: {
+            weight,
+            fileScore,
+            driftSeverity: issue.severity,
+            ...extraProperties,
+        },
+    };
+}
+function buildRules(results) {
+    const byRule = new Map();
+    for (const result of results) {
+        if (byRule.has(result.ruleId))
+            continue;
+        byRule.set(result.ruleId, {
+            id: result.ruleId,
+            name: result.ruleId,
+            shortDescription: {
+                text: `drift rule: ${result.ruleId}`,
+            },
+            defaultConfiguration: {
+                level: result.level,
+            },
+            properties: {
+                weight: result.properties?.weight,
+            },
+        });
+    }
+    return [...byRule.values()];
+}
+function buildSarifLog(results, metrics) {
+    return {
+        $schema: SARIF_SCHEMA_URL,
+        version: '2.1.0',
+        runs: [{
+                tool: {
+                    driver: {
+                        name: 'drift',
+                        version: VERSION,
+                        informationUri: DRIFT_INFORMATION_URI,
+                        rules: buildRules(results),
+                    },
+                },
+                results,
+                properties: metrics,
+            }],
+    };
+}
+export function toSarif(report) {
+    const results = report.files.flatMap((file) => file.issues.map((issue) => toSarifResult(file.path, file.score, issue)));
+    return buildSarifLog(results, {
+        scannedAt: report.scannedAt,
+        targetPath: report.targetPath,
+        totalIssues: report.totalIssues,
+        totalScore: report.totalScore,
+        totalFiles: report.totalFiles,
+    });
+}
+export function diffToSarif(diff) {
+    const results = diff.files.flatMap((file) => file.newIssues.map((issue) => toSarifResult(file.path, file.scoreAfter, issue, {
+        baseRef: diff.baseRef,
+        scoreBefore: file.scoreBefore,
+        scoreAfter: file.scoreAfter,
+        scoreDelta: file.scoreDelta,
+        changeType: 'new-issue',
+    })));
+    return buildSarifLog(results, {
+        scannedAt: diff.scannedAt,
+        targetPath: diff.projectPath,
+        totalIssues: diff.newIssuesCount,
+        totalScore: diff.totalScoreAfter,
+        totalFiles: diff.files.length,
+        baseRef: diff.baseRef,
+        totalDelta: diff.totalDelta,
+        newIssuesCount: diff.newIssuesCount,
+        resolvedIssuesCount: diff.resolvedIssuesCount,
+    });
+}
+//# sourceMappingURL=sarif.js.map

package/dist/trust-advanced.d.ts

@@ -0,0 +1,14 @@
+import type { DriftReport, DriftTrustReport, TrustDiffContext, TrustFixPriority } from './types.js';
+import type { SnapshotEntry } from './snapshot.js';
+export declare function buildAdvancedContext(input: {
+    report: DriftReport;
+    advancedOptions: {
+        enabled?: boolean;
+        previousTrust?: Partial<DriftTrustReport>;
+        snapshots?: SnapshotEntry[];
+    } | undefined;
+    trustScore: number;
+    fixPriorities: TrustFixPriority[];
+    diffContext: TrustDiffContext | undefined;
+}): DriftTrustReport['advanced_context'];
+//# sourceMappingURL=trust-advanced.d.ts.map

package/dist/trust-advanced.js

@@ -0,0 +1,65 @@
+const SYSTEMIC_GUIDANCE_LIMIT = 2;
+const TEAM_GUIDANCE_LIMIT = 3;
+function buildComparisonFromPreviousTrust(trustScore, previousTrust) {
+    if (!previousTrust || typeof previousTrust.trust_score !== 'number')
+        return undefined;
+    const trustDelta = trustScore - previousTrust.trust_score;
+    const trend = trustDelta > 0 ? 'improving' : trustDelta < 0 ? 'regressing' : 'stable';
+    return {
+        source: 'previous-trust-json',
+        trend,
+        summary: `Trust moved ${trustDelta >= 0 ? '+' : ''}${trustDelta} vs provided previous trust JSON.`,
+        trust_delta: trustDelta,
+        previous_trust_score: previousTrust.trust_score,
+        previous_merge_risk: previousTrust.merge_risk,
+    };
+}
+function buildComparisonFromSnapshotHistory(report, snapshots) {
+    const lastSnapshot = snapshots && snapshots.length > 0 ? snapshots[snapshots.length - 1] : undefined;
+    if (!lastSnapshot)
+        return undefined;
+    const snapshotScoreDelta = report.totalScore - lastSnapshot.score;
+    const trend = snapshotScoreDelta < 0 ? 'improving' : snapshotScoreDelta > 0 ? 'regressing' : 'stable';
+    const snapshotContext = lastSnapshot.label
+        ? `${lastSnapshot.timestamp} (${lastSnapshot.label})`
+        : lastSnapshot.timestamp;
+    return {
+        source: 'snapshot-history',
+        trend,
+        summary: `Drift score moved ${snapshotScoreDelta >= 0 ? '+' : ''}${snapshotScoreDelta} vs snapshot ${snapshotContext}.`,
+        snapshot_score_delta: snapshotScoreDelta,
+        snapshot_label: lastSnapshot.label || undefined,
+        snapshot_timestamp: lastSnapshot.timestamp,
+    };
+}
+function buildTeamGuidance(priorities, comparison, diffContext) {
+    const systemicTargets = priorities
+        .filter((priority) => priority.systemic)
+        .slice(0, SYSTEMIC_GUIDANCE_LIMIT)
+        .map((priority) => `${priority.rule} (x${priority.occurrences})`);
+    const guidance = [];
+    if (systemicTargets.length > 0) {
+        guidance.push(`Start with systemic rules: ${systemicTargets.join(', ')}.`);
+    }
+    if (comparison?.trend === 'regressing') {
+        guidance.push('Trend regressed; freeze net-new debt in CI and assign owners per systemic rule.');
+    }
+    if (diffContext && diffContext.newIssues > 0) {
+        guidance.push(`Block net-new issue growth first (+${diffContext.newIssues} new issue(s) in diff context).`);
+    }
+    if (guidance.length === 0) {
+        guidance.push('Maintain current baseline and schedule periodic systemic debt cleanup by rule ownership.');
+    }
+    return guidance.slice(0, TEAM_GUIDANCE_LIMIT);
+}
+export function buildAdvancedContext(input) {
+    if (input.advancedOptions?.enabled !== true)
+        return undefined;
+    const comparison = buildComparisonFromPreviousTrust(input.trustScore, input.advancedOptions.previousTrust)
+        ?? buildComparisonFromSnapshotHistory(input.report, input.advancedOptions.snapshots);
+    return {
+        comparison,
+        team_guidance: buildTeamGuidance(input.fixPriorities, comparison, input.diffContext),
+    };
+}
+//# sourceMappingURL=trust-advanced.js.map

package/dist/trust-kpi-fs.d.ts

@@ -0,0 +1,3 @@
+import type { DiscoverResult } from './trust-kpi-types.js';
+export declare function discoverTrustJsonFiles(input: string, cwd: string): DiscoverResult;
+//# sourceMappingURL=trust-kpi-fs.d.ts.map