@eduardbar/drift 1.2.0 → 1.4.0

package/src/reporter.ts

@@ -1,71 +1,60 @@
-import type { FileReport, DriftReport, DriftIssue, AIOutput, AIIssue } from './types.js'
+import type {
+  FileReport,
+  DriftReport,
+  DriftIssue,
+  AIOutput,
+  AIIssue,
+  AIOutputJson,
+  DriftReportJson,
+} from './types.js'
 import { scoreToGradeText, severityIcon } from './utils.js'
 import { computeRepoQuality, computeMaintenanceRisk } from './metrics.js'
+import { OUTPUT_SCHEMA, withOutputMetadata } from './output-metadata.js'
+import {
+  AI_CODE_SMELL_BOOST,
+  AI_LIKELIHOOD_THRESHOLD,
+  AI_SIGNAL_RULES,
+  AI_SMELL_SCORE_MULTIPLIER,
+  AI_SUSPECTED_LIMIT,
+  AI_TRIGGER_LIMIT,
+  EFFORT_ORDER,
+  FIX_SUGGESTIONS,
+  RULE_EFFORT,
+  SEVERITY_ORDER,
+  type DriftIssueWithFile,
+} from './reporter-constants.js'
 
-const FIX_SUGGESTIONS: Record<string, string> = {
-  'large-file': 'Consider splitting this file into smaller modules with single responsibility',
-  'large-function': 'Extract logic into smaller functions with descriptive names',
-  'debug-leftover': 'Remove this console.log or replace with proper logging library',
-  'dead-code': 'Remove unused import to keep code clean',
-  'duplicate-function-name': 'Consolidate with existing function or rename to clarify different behavior',
-  'any-abuse': "Replace 'any' with proper type definition",
-  'catch-swallow': 'Add error handling or logging in catch block',
-  'no-return-type': 'Add explicit return type for better type safety',
-}
-
-const RULE_EFFORT: Record<string, 'low' | 'medium' | 'high'> = {
-  'debug-leftover': 'low',
-  'dead-code': 'low',
-  'no-return-type': 'low',
-  'any-abuse': 'medium',
-  'catch-swallow': 'medium',
-  'large-file': 'high',
-  'large-function': 'high',
-  'duplicate-function-name': 'high',
-}
-
-const SEVERITY_ORDER: Record<string, number> = { error: 0, warning: 1, info: 2 }
-const EFFORT_ORDER: Record<string, number> = { low: 0, medium: 1, high: 2 }
-const AI_SIGNAL_RULES = new Set([
-  'over-commented',
-  'hardcoded-config',
-  'inconsistent-error-handling',
-  'unnecessary-abstraction',
-  'naming-inconsistency',
-  'comment-contradiction',
-  'promise-style-mix',
-  'any-abuse',
-  'ai-code-smell',
-])
-
-export function buildReport(targetPath: string, files: FileReport[]): DriftReport {
-  const allIssues = files.flatMap((f) => f.issues)
+function summarizeIssues(allIssues: DriftIssue[]): DriftReport['summary'] {
   const byRule: Record<string, number> = {}
 
   for (const issue of allIssues) {
     byRule[issue.rule] = (byRule[issue.rule] ?? 0) + 1
   }
 
-  const totalScore =
-    files.length > 0
-      ? Math.round(files.reduce((sum, f) => sum + f.score, 0) / files.length)
-      : 0
+  return {
+    errors: allIssues.filter((issue) => issue.severity === 'error').length,
+    warnings: allIssues.filter((issue) => issue.severity === 'warning').length,
+    infos: allIssues.filter((issue) => issue.severity === 'info').length,
+    byRule,
+  }
+}
 
-  const sortedFiles = files.filter((f) => f.issues.length > 0).sort((a, b) => b.score - a.score)
+function calculateTotalScore(files: FileReport[]): number {
+  if (files.length === 0) return 0
+  return Math.round(files.reduce((sum, file) => sum + file.score, 0) / files.length)
+}
 
-  const baseReport: DriftReport = {
+function baseReportDefaults(summary: DriftReport['summary'], targetPath: string, files: FileReport[]): DriftReportJson {
+  const filesWithIssues = files.filter((file) => file.issues.length > 0).sort((a, b) => b.score - a.score)
+
+  const report: DriftReport = {
     scannedAt: new Date().toISOString(),
     targetPath,
-    files: sortedFiles,
-    totalIssues: allIssues.length,
-    totalScore,
+    files: filesWithIssues,
+    totalIssues: files.flatMap((file) => file.issues).length,
+    totalScore: calculateTotalScore(files),
     totalFiles: files.length,
-    summary: {
-      errors: allIssues.filter((i) => i.severity === 'error').length,
-      warnings: allIssues.filter((i) => i.severity === 'warning').length,
-      infos: allIssues.filter((i) => i.severity === 'info').length,
-      byRule,
-    },
+    summary,
     quality: {
       overall: 100,
       dimensions: {
@@ -87,6 +76,14 @@ export function buildReport(targetPath: string, files: FileReport[]): DriftRepor
     },
   }
 
+  return withOutputMetadata(report, OUTPUT_SCHEMA.report)
+}
+
+export function buildReport(targetPath: string, files: FileReport[]): DriftReportJson {
+  const allIssues = files.flatMap((f) => f.issues)
+  const summary = summarizeIssues(allIssues)
+  const baseReport = baseReportDefaults(summary, targetPath, files)
+
   baseReport.quality = computeRepoQuality(targetPath, files)
   baseReport.maintenanceRisk = computeMaintenanceRisk(baseReport)
 
@@ -158,8 +155,8 @@ export function formatMarkdown(report: DriftReport): string {
   return lines.join('\n')
 }
 
-function collectAllIssues(report: DriftReport): Array<{ file: string; issue: DriftIssue }> {
-  const all: Array<{ file: string; issue: DriftIssue }> = []
+function collectAllIssues(report: DriftReport): DriftIssueWithFile[] {
+  const all: DriftIssueWithFile[] = []
   for (const file of report.files) {
     for (const issue of file.issues) {
       all.push({ file: file.path, issue })
@@ -168,7 +165,7 @@ function collectAllIssues(report: DriftReport): Array<{ file: string; issue: Dri
   return all
 }
 
-function sortIssues(issues: Array<{ file: string; issue: DriftIssue }>): Array<{ file: string; issue: DriftIssue }> {
+function sortIssues(issues: DriftIssueWithFile[]): DriftIssueWithFile[] {
   return issues.sort((a, b) => {
     const sevDiff = SEVERITY_ORDER[a.issue.severity] - SEVERITY_ORDER[b.issue.severity]
     if (sevDiff !== 0) return sevDiff
@@ -178,7 +175,7 @@ function sortIssues(issues: Array<{ file: string; issue: DriftIssue }>): Array<{
   })
 }
 
-function buildAIIssue(item: { file: string; issue: DriftIssue }, rank: number): AIIssue {
+function buildAIIssue(item: DriftIssueWithFile, rank: number): AIIssue {
   return {
     rank,
     file: item.file,
@@ -209,12 +206,12 @@ function fileAILikelihood(fileIssues: DriftIssue[]): { score: number; triggers:
     triggerCounts.set(issue.rule, (triggerCounts.get(issue.rule) ?? 0) + 1)
   }
   const triggerTotal = [...triggerCounts.values()].reduce((sum, count) => sum + count, 0)
-  const smellBoost = fileIssues.some((issue) => issue.rule === 'ai-code-smell') ? 20 : 0
+  const smellBoost = fileIssues.some((issue) => issue.rule === 'ai-code-smell') ? AI_CODE_SMELL_BOOST : 0
   const ratioScore = Math.round((triggerTotal / Math.max(fileIssues.length, 1)) * 100)
   const score = Math.max(0, Math.min(100, ratioScore + smellBoost))
   const triggers = [...triggerCounts.entries()]
     .sort((a, b) => b[1] - a[1])
-    .slice(0, 4)
+    .slice(0, AI_TRIGGER_LIMIT)
     .map(([rule]) => rule)
   return { score, triggers }
 }
@@ -233,7 +230,7 @@ function computeAILikelihood(report: DriftReport): {
         triggers: likelihood.triggers,
       }
     })
-    .filter((entry) => entry.ai_likelihood >= 35)
+    .filter((entry) => entry.ai_likelihood >= AI_LIKELIHOOD_THRESHOLD)
     .sort((a, b) => b.ai_likelihood - a.ai_likelihood)
 
   const overall = suspected.length === 0
@@ -241,16 +238,16 @@ function computeAILikelihood(report: DriftReport): {
     : Math.round(suspected.reduce((sum, entry) => sum + entry.ai_likelihood, 0) / suspected.length)
 
   const smellCount = report.files.flatMap((file) => file.issues).filter((issue) => issue.rule === 'ai-code-smell').length
-  const smellScore = Math.min(100, smellCount * 15)
+  const smellScore = Math.min(100, smellCount * AI_SMELL_SCORE_MULTIPLIER)
 
   return {
     overall,
-    files: suspected.slice(0, 10),
+    files: suspected.slice(0, AI_SUSPECTED_LIMIT),
     smellScore,
   }
 }
 
-export function formatAIOutput(report: DriftReport): AIOutput {
+export function formatAIOutput(report: DriftReport): AIOutputJson {
   const allIssues = collectAllIssues(report)
   const sortedIssues = sortIssues(allIssues)
   const priorityOrder = sortedIssues.map((item, i) => buildAIIssue(item, i + 1))
@@ -258,7 +255,7 @@ export function formatAIOutput(report: DriftReport): AIOutput {
   const grade = scoreToGradeText(report.totalScore)
   const aiLikelihood = computeAILikelihood(report)
 
-  return {
+  const output: AIOutput = {
     summary: {
       score: report.totalScore,
       grade: grade.label.toUpperCase(),
@@ -279,4 +276,6 @@ export function formatAIOutput(report: DriftReport): AIOutput {
       recommended_action: buildRecommendedAction(priorityOrder),
     },
   }
+
+  return withOutputMetadata(output, OUTPUT_SCHEMA.ai)
 }

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'
@@ -6,7 +6,7 @@ import { cleanupTempDir, extractFilesAtRef } from './git.js'
 import { computeDiff } from './diff.js'
 import type { DriftDiff } from './types.js'
 
-export interface DriftReview {
+interface DriftReview {
   baseRef: string
   scannedAt: string
   totalDelta: number
@@ -18,10 +18,12 @@ export interface DriftReview {
   diff: DriftDiff
 }
 
+const REVIEW_TOP_FILES_LIMIT = 8
+
 export function formatReviewMarkdown(review: DriftReview): string {
   const trendIcon = review.status === 'regressed' ? '⚠️' : review.status === 'improved' ? '✅' : 'ℹ️'
   const topFiles = review.diff.files
-    .slice(0, 8)
+    .slice(0, REVIEW_TOP_FILES_LIMIT)
     .map((file) => {
       const sign = file.scoreDelta > 0 ? '+' : ''
       return `- \`${file.path}\`: ${file.scoreBefore} -> ${file.scoreAfter} (${sign}${file.scoreDelta}), +${file.newIssues.length} new / -${file.resolvedIssues.length} resolved`
@@ -66,7 +68,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()

package/src/rules/complexity.ts

@@ -1,6 +1,6 @@
 import { SourceFile, SyntaxKind } from 'ts-morph'
 import type { DriftIssue } from '../types.js'
-import { hasIgnoreComment, getSnippet, type FunctionLike } from './shared.js'
+import { hasIgnoreComment, getSnippet, collectFunctionLikes, type FunctionLike } from './shared.js'
 
 const COMPLEXITY_THRESHOLD = 10
 
@@ -31,12 +31,7 @@ function getCyclomaticComplexity(fn: FunctionLike): number {
 
 export function detectHighComplexity(file: SourceFile): DriftIssue[] {
   const issues: DriftIssue[] = []
-  const fns: FunctionLike[] = [
-    ...file.getFunctions(),
-    ...file.getDescendantsOfKind(SyntaxKind.ArrowFunction),
-    ...file.getDescendantsOfKind(SyntaxKind.FunctionExpression),
-    ...file.getClasses().flatMap((c) => c.getMethods()),
-  ]
+  const fns: FunctionLike[] = collectFunctionLikes(file)
 
   for (const fn of fns) {
     const complexity = getCyclomaticComplexity(fn)

package/src/rules/nesting.ts

@@ -1,6 +1,6 @@
 import { SourceFile, SyntaxKind, Node } from 'ts-morph'
 import type { DriftIssue } from '../types.js'
-import { hasIgnoreComment, getSnippet, type FunctionLike } from './shared.js'
+import { hasIgnoreComment, getSnippet, collectFunctionLikes, type FunctionLike } from './shared.js'
 
 const NESTING_THRESHOLD = 3
 const PARAMS_THRESHOLD = 4
@@ -35,12 +35,7 @@ function getMaxNestingDepth(fn: FunctionLike): number {
 
 export function detectDeepNesting(file: SourceFile): DriftIssue[] {
   const issues: DriftIssue[] = []
-  const fns: FunctionLike[] = [
-    ...file.getFunctions(),
-    ...file.getDescendantsOfKind(SyntaxKind.ArrowFunction),
-    ...file.getDescendantsOfKind(SyntaxKind.FunctionExpression),
-    ...file.getClasses().flatMap((c) => c.getMethods()),
-  ]
+  const fns: FunctionLike[] = collectFunctionLikes(file)
 
   for (const fn of fns) {
     const depth = getMaxNestingDepth(fn)
@@ -62,12 +57,7 @@ export function detectDeepNesting(file: SourceFile): DriftIssue[] {
 
 export function detectTooManyParams(file: SourceFile): DriftIssue[] {
   const issues: DriftIssue[] = []
-  const fns: FunctionLike[] = [
-    ...file.getFunctions(),
-    ...file.getDescendantsOfKind(SyntaxKind.ArrowFunction),
-    ...file.getDescendantsOfKind(SyntaxKind.FunctionExpression),
-    ...file.getClasses().flatMap((c) => c.getMethods()),
-  ]
+  const fns: FunctionLike[] = collectFunctionLikes(file)
 
   for (const fn of fns) {
     const paramCount = fn.getParameters().length

package/src/rules/phase0-basic.ts

@@ -1,6 +1,6 @@
 import { SourceFile, SyntaxKind } from 'ts-morph'
 import type { DriftIssue } from '../types.js'
-import { hasIgnoreComment, getSnippet, getFunctionLikeLines, type FunctionLike } from './shared.js'
+import { hasIgnoreComment, getSnippet, getFunctionLikeLines, collectFunctionLikes, getFileLines } from './shared.js'
 
 const LARGE_FILE_THRESHOLD = 300
 const LARGE_FUNCTION_THRESHOLD = 50
@@ -26,12 +26,7 @@ export function detectLargeFile(file: SourceFile): DriftIssue[] {
 
 export function detectLargeFunctions(file: SourceFile): DriftIssue[] {
   const issues: DriftIssue[] = []
-  const fns: FunctionLike[] = [
-    ...file.getFunctions(),
-    ...file.getDescendantsOfKind(SyntaxKind.ArrowFunction),
-    ...file.getDescendantsOfKind(SyntaxKind.FunctionExpression),
-    ...file.getClasses().flatMap((c) => c.getMethods()),
-  ]
+  const fns = collectFunctionLikes(file)
 
   for (const fn of fns) {
     const lines = getFunctionLikeLines(fn)
@@ -70,7 +65,7 @@ export function detectDebugLeftovers(file: SourceFile): DriftIssue[] {
     }
   }
 
-  const lines = file.getFullText().split('\n')
+  const lines = getFileLines(file)
   lines.forEach((lineContent, i) => {
     if (/\/\/\s*(TODO|FIXME|HACK|XXX|TEMP)\b/i.test(lineContent)) {
       if (hasIgnoreComment(file, i + 1)) return
@@ -90,14 +85,18 @@ export function detectDebugLeftovers(file: SourceFile): DriftIssue[] {
 
 export function detectDeadCode(file: SourceFile): DriftIssue[] {
   const issues: DriftIssue[] = []
+  const identifierCounts = new Map<string, number>()
+
+  for (const id of file.getDescendantsOfKind(SyntaxKind.Identifier)) {
+    const text = id.getText()
+    identifierCounts.set(text, (identifierCounts.get(text) ?? 0) + 1)
+  }
 
   for (const imp of file.getImportDeclarations()) {
     for (const named of imp.getNamedImports()) {
       const name = named.getName()
-      const refs = file.getDescendantsOfKind(SyntaxKind.Identifier).filter(
-        (id) => id.getText() === name && id !== named.getNameNode()
-      )
-      if (refs.length === 0) {
+      const refsCount = Math.max(0, (identifierCounts.get(name) ?? 0) - 1)
+      if (refsCount === 0) {
         issues.push({
           rule: 'dead-code',
           severity: 'warning',

package/src/rules/phase3-configurable.ts

@@ -23,12 +23,14 @@ const HTTP_IMPORT_PATTERNS = [
 
 function isControllerFile(filePath: string): boolean {
   const normalized = filePath.replace(/\\/g, '/').toLowerCase()
-  return normalized.includes('/controller/') || normalized.includes('/controllers/') || normalized.endsWith('controller.ts') || normalized.endsWith('controller.js')
+  const segments = normalized.split('/')
+  return segments.includes('controller') || segments.includes('controllers') || normalized.endsWith('controller.ts') || normalized.endsWith('controller.js')
 }
 
 function isServiceFile(filePath: string): boolean {
   const normalized = filePath.replace(/\\/g, '/').toLowerCase()
-  return normalized.includes('/service/') || normalized.includes('/services/') || normalized.endsWith('service.ts') || normalized.endsWith('service.js')
+  const segments = normalized.split('/')
+  return segments.includes('service') || segments.includes('services') || normalized.endsWith('service.ts') || normalized.endsWith('service.js')
 }
 
 function createIssue(rule: string, message: string, line: number, snippet: string): DriftIssue {
@@ -100,33 +102,44 @@ export function detectMaxFunctionLines(file: SourceFile, config?: DriftConfig):
 
   const issues: DriftIssue[] = []
 
+  collectFunctionLineIssues(file, maxLines, issues)
+  collectMethodLineIssues(file, maxLines, issues)
+
+  return issues
+}
+
+function countBodyLines(
+  body: ReturnType<import('ts-morph').FunctionDeclaration['getBody']> | ReturnType<import('ts-morph').MethodDeclaration['getBody']>,
+): number {
+  if (!body) return 0
+  return body.getEndLineNumber() - body.getStartLineNumber() - 1
+}
+
+function collectFunctionLineIssues(file: SourceFile, maxLines: number, issues: DriftIssue[]): void {
   for (const fn of file.getFunctions()) {
-    const body = fn.getBody()
-    if (!body) continue
-    const lines = body.getEndLineNumber() - body.getStartLineNumber() - 1
-    if (lines > maxLines) {
-      issues.push(createIssue(
-        'max-function-lines',
-        `Function '${fn.getName() ?? '(anonymous)'}' has ${lines} lines (max: ${maxLines}).`,
-        fn.getStartLineNumber(),
-        fn.getName() ?? '(anonymous)',
-      ))
-    }
+    const lines = countBodyLines(fn.getBody())
+    if (lines <= maxLines) continue
+
+    const functionName = fn.getName() ?? '(anonymous)'
+    issues.push(createIssue(
+      'max-function-lines',
+      `Function '${functionName}' has ${lines} lines (max: ${maxLines}).`,
+      fn.getStartLineNumber(),
+      functionName,
+    ))
   }
+}
 
+function collectMethodLineIssues(file: SourceFile, maxLines: number, issues: DriftIssue[]): void {
   for (const method of file.getDescendantsOfKind(SyntaxKind.MethodDeclaration)) {
-    const body = method.getBody()
-    if (!body) continue
-    const lines = body.getEndLineNumber() - body.getStartLineNumber() - 1
-    if (lines > maxLines) {
-      issues.push(createIssue(
-        'max-function-lines',
-        `Method '${method.getName()}' has ${lines} lines (max: ${maxLines}).`,
-        method.getStartLineNumber(),
-        method.getName(),
-      ))
-    }
+    const lines = countBodyLines(method.getBody())
+    if (lines <= maxLines) continue
+
+    issues.push(createIssue(
+      'max-function-lines',
+      `Method '${method.getName()}' has ${lines} lines (max: ${maxLines}).`,
+      method.getStartLineNumber(),
+      method.getName(),
+    ))
   }
-
-  return issues
 }

package/src/rules/shared.ts

@@ -5,12 +5,40 @@ import {
   ArrowFunction,
   FunctionExpression,
   MethodDeclaration,
+  SyntaxKind,
 } from 'ts-morph'
 
 export type FunctionLike = FunctionDeclaration | ArrowFunction | FunctionExpression | MethodDeclaration
 
-export function hasIgnoreComment(file: SourceFile, line: number): boolean {
+const fileLinesCache = new WeakMap<SourceFile, string[]>()
+const functionLikesCache = new WeakMap<SourceFile, FunctionLike[]>()
+
+export function getFileLines(file: SourceFile): string[] {
+  const cached = fileLinesCache.get(file)
+  if (cached) return cached
+
   const lines = file.getFullText().split('\n')
+  fileLinesCache.set(file, lines)
+  return lines
+}
+
+export function collectFunctionLikes(file: SourceFile): FunctionLike[] {
+  const cached = functionLikesCache.get(file)
+  if (cached) return cached
+
+  const fns: FunctionLike[] = [
+    ...file.getFunctions(),
+    ...file.getDescendantsOfKind(SyntaxKind.ArrowFunction),
+    ...file.getDescendantsOfKind(SyntaxKind.FunctionExpression),
+    ...file.getClasses().flatMap((c) => c.getMethods()),
+  ]
+
+  functionLikesCache.set(file, fns)
+  return fns
+}
+
+export function hasIgnoreComment(file: SourceFile, line: number): boolean {
+  const lines = getFileLines(file)
   const currentLine = lines[line - 1] ?? ''
   const prevLine = lines[line - 2] ?? ''
 
@@ -20,13 +48,13 @@ export function hasIgnoreComment(file: SourceFile, line: number): boolean {
 }
 
 export function isFileIgnored(file: SourceFile): boolean {
-  const firstLines = file.getFullText().split('\n').slice(0, 10).join('\n') // drift-ignore
+  const firstLines = getFileLines(file).slice(0, 10).join('\n') // drift-ignore
   return /\/\/\s*drift-ignore-file\b/.test(firstLines)
 }
 
 export function getSnippet(node: Node, file: SourceFile): string {
   const startLine = node.getStartLineNumber()
-  const lines = file.getFullText().split('\n')
+  const lines = getFileLines(file)
   return lines
     .slice(Math.max(0, startLine - 1), startLine + 1)
     .join('\n')

package/src/saas/constants.ts

@@ -0,0 +1,56 @@
+import type { SaasOperation, SaasPlan, SaasPolicy, SaasRole } from './types.js'
+
+export const STORE_VERSION = 3
+export const ACTIVE_WINDOW_DAYS = 30
+export const DEFAULT_ORGANIZATION_ID = 'default-org'
+const HOURS_PER_DAY = 24
+const MINUTES_PER_HOUR = 60
+const SECONDS_PER_MINUTE = 60
+const MILLISECONDS_PER_SECOND = 1000
+const RANDOM_ID_RADIX = 16
+const RANDOM_ID_START = 2
+const RANDOM_ID_END = 10
+
+export const DASHBOARD_REPO_LIMIT = 15
+export const DASHBOARD_BAR_UNIT = 8
+export const DASHBOARD_BAR_MIN_WIDTH = 8
+
+export const VALID_ROLES: SaasRole[] = ['owner', 'member', 'viewer']
+export const VALID_PLANS: SaasPlan[] = ['free', 'sponsor', 'team', 'business']
+
+export const ROLE_PRIORITY: Record<SaasRole, number> = {
+  viewer: 1,
+  member: 2,
+  owner: 3,
+}
+
+export const REQUIRED_ROLE_BY_OPERATION: Record<SaasOperation, SaasRole> = {
+  'snapshot:write': 'member',
+  'snapshot:read': 'viewer',
+  'summary:read': 'viewer',
+  'billing:write': 'owner',
+  'billing:read': 'viewer',
+}
+
+export const DEFAULT_SAAS_POLICY: SaasPolicy = {
+  freeUserThreshold: 7500,
+  maxRunsPerWorkspacePerMonth: 500,
+  maxReposPerWorkspace: 20,
+  retentionDays: 90,
+  strictActorEnforcement: false,
+  maxWorkspacesPerOrganizationByPlan: {
+    free: 20,
+    sponsor: 50,
+    team: 200,
+    business: 1000,
+  },
+}
+
+export function daysAgo(days: number): number {
+  const now = Date.now()
+  return now - days * HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MILLISECONDS_PER_SECOND
+}
+
+export function createRandomId(prefix: string): string {
+  return `${prefix}-${Math.random().toString(RANDOM_ID_RADIX).slice(RANDOM_ID_START, RANDOM_ID_END)}`
+}