@alumbwe/anvil 1.0.20 → 1.0.21

package/vendor/@anvil/common/src/util/min-heap.ts

@@ -0,0 +1,87 @@
+/**
+ * A generic min heap implementation that maintains elements ordered by a numeric score.
+ */
+export class MinHeap<T> {
+  private heap: { item: T; score: number }[] = []
+
+  private getParentIndex(index: number): number {
+    return Math.floor((index - 1) / 2)
+  }
+
+  private getLeftChildIndex(index: number): number {
+    return 2 * index + 1
+  }
+
+  private getRightChildIndex(index: number): number {
+    return 2 * index + 2
+  }
+
+  private swap(index1: number, index2: number): void {
+    const temp = this.heap[index1]
+    this.heap[index1] = this.heap[index2]
+    this.heap[index2] = temp
+  }
+
+  private siftUp(index: number): void {
+    while (index > 0) {
+      const parentIndex = this.getParentIndex(index)
+      if (this.heap[parentIndex].score <= this.heap[index].score) {
+        break
+      }
+      this.swap(index, parentIndex)
+      index = parentIndex
+    }
+  }
+
+  private siftDown(index: number): void {
+    while (true) {
+      let minIndex = index
+      const leftChild = this.getLeftChildIndex(index)
+      const rightChild = this.getRightChildIndex(index)
+
+      if (
+        leftChild < this.heap.length &&
+        this.heap[leftChild].score < this.heap[minIndex].score
+      ) {
+        minIndex = leftChild
+      }
+
+      if (
+        rightChild < this.heap.length &&
+        this.heap[rightChild].score < this.heap[minIndex].score
+      ) {
+        minIndex = rightChild
+      }
+
+      if (minIndex === index) {
+        break
+      }
+
+      this.swap(index, minIndex)
+      index = minIndex
+    }
+  }
+
+  insert(item: T, score: number): void {
+    this.heap.push({ item, score })
+    this.siftUp(this.heap.length - 1)
+  }
+
+  extractMin(): T | undefined {
+    if (this.heap.length === 0) return undefined
+
+    const minItem = this.heap[0].item
+    const last = this.heap.pop()!
+
+    if (this.heap.length > 0) {
+      this.heap[0] = last
+      this.siftDown(0)
+    }
+
+    return minItem
+  }
+
+  get size(): number {
+    return this.heap.length
+  }
+}

package/vendor/@anvil/common/src/util/model-utils.ts

@@ -0,0 +1,4 @@
+// Compatibility export for callers that imported the old utility path. The
+// implementation lives beside `models`, avoiding the old model-config ->
+// model-utils -> old-constants -> model-config cycle and its CommonJS require.
+export { isExplicitlyDefinedModel } from '../constants/model-config'

package/vendor/@anvil/common/src/util/object.ts

@@ -0,0 +1,128 @@
+import { isEqual, mapValues, union } from 'lodash'
+
+type RemoveUndefined<T extends object> = {
+  [K in keyof T as T[K] extends undefined ? never : K]: Exclude<T[K], undefined>
+}
+
+export const removeUndefinedProps = <T extends object>(
+  obj: T,
+): RemoveUndefined<T> => {
+  const newObj: Record<string, unknown> = {}
+
+  for (const key of Object.keys(obj)) {
+    const value = obj[key as keyof T]
+    if (value !== undefined) {
+      newObj[key] = value
+    }
+  }
+
+  return newObj as RemoveUndefined<T>
+}
+
+export const removeNullOrUndefinedProps = <T extends object>(
+  obj: T,
+  exceptions?: string[],
+): T => {
+  const newObj: Record<string, unknown> = {}
+
+  for (const key of Object.keys(obj)) {
+    const value = obj[key as keyof T]
+    if (
+      (value !== undefined && value !== null) ||
+      (exceptions ?? []).includes(key)
+    ) {
+      newObj[key] = value
+    }
+  }
+  return newObj as T
+}
+
+export const addObjects = <T extends { [key: string]: number }>(
+  obj1: T,
+  obj2: T,
+): T => {
+  const keys = union(Object.keys(obj1), Object.keys(obj2))
+  const newObj: { [key: string]: number } = {}
+
+  for (const key of keys) {
+    newObj[key] = (obj1[key] ?? 0) + (obj2[key] ?? 0)
+  }
+
+  return newObj as T
+}
+
+export const subtractObjects = <T extends { [key: string]: number }>(
+  obj1: T,
+  obj2: T,
+): T => {
+  const keys = union(Object.keys(obj1), Object.keys(obj2))
+  const newObj: { [key: string]: number } = {}
+
+  for (const key of keys) {
+    newObj[key] = (obj1[key] ?? 0) - (obj2[key] ?? 0)
+  }
+
+  return newObj as T
+}
+
+export const hasChanges = <T extends object>(obj: T, partial: Partial<T>) => {
+  const currValues = mapValues(partial, (_, key: keyof T) => obj[key])
+  return !isEqual(currValues, partial)
+}
+
+export const hasSignificantDeepChanges = <T extends object>(
+  obj: T,
+  partial: Partial<T>,
+  epsilonForNumbers: number,
+): boolean => {
+  const compareValues = (currValue: any, partialValue: any): boolean => {
+    if (typeof currValue === 'number' && typeof partialValue === 'number') {
+      return Math.abs(currValue - partialValue) > epsilonForNumbers
+    }
+    if (typeof currValue === 'object' && typeof partialValue === 'object') {
+      return hasSignificantDeepChanges(
+        currValue,
+        partialValue,
+        epsilonForNumbers,
+      )
+    }
+    return !isEqual(currValue, partialValue)
+  }
+
+  for (const key in partial) {
+    if (Object.prototype.hasOwnProperty.call(partial, key)) {
+      if (compareValues(obj[key], partial[key])) {
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
+export const filterObject = <T extends object>(
+  obj: T,
+  predicate: (value: any, key: keyof T) => boolean,
+): { [P in keyof T]: T[P] } => {
+  const result = {} as { [P in keyof T]: T[P] }
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      if (predicate(obj[key], key)) {
+        result[key] = obj[key]
+      }
+    }
+  }
+  return result
+}
+
+/**
+ * Asserts that a condition is true. If the condition is false, it throws an error with the provided message.
+ * @param condition The condition to check
+ * @param message The error message to display if the condition is false
+ * @throws {Error} If the condition is false
+ */
+export function assert(condition: boolean, message: string): asserts condition {
+  if (!condition) {
+    throw new Error(`Assertion failed: ${message}`)
+  }
+}

package/vendor/@anvil/common/src/util/partial-json-delta.ts

@@ -0,0 +1,89 @@
+export function parsePartialJsonObjectSingle(content: string): {
+  lastParamComplete: boolean
+  params: any
+} {
+  try {
+    return { lastParamComplete: true, params: JSON.parse(content) }
+  } catch {}
+
+  if (!content.match(/\d$/)) {
+    try {
+      return { lastParamComplete: true, params: JSON.parse(content + '}') }
+    } catch {}
+  }
+
+  try {
+    return { lastParamComplete: false, params: JSON.parse(content + '"}') }
+  } catch {}
+
+  if (content.endsWith('\\')) {
+    try {
+      return {
+        lastParamComplete: false,
+        params: JSON.parse(content.slice(0, -1) + '"}'),
+      }
+    } catch {}
+  }
+
+  let commaPos = content.length
+  while ((commaPos = content.lastIndexOf(',', commaPos - 1)) !== -1) {
+    try {
+      return {
+        lastParamComplete: true,
+        params: JSON.parse(content.slice(0, commaPos) + '}'),
+      }
+    } catch {}
+  }
+
+  return { lastParamComplete: true, params: {} }
+}
+
+export function getPartialJsonDelta(
+  content: string,
+  previous: string,
+): {
+  delta: Record<string, any>
+  result: Record<string, any>
+  lastParam: { key: string | undefined; complete: boolean }
+} {
+  if (!content.startsWith(previous)) {
+    throw new Error(
+      `Content must be previous content plus new content. Content ${JSON.stringify(content)} does not start with previous content ${JSON.stringify(previous)}`,
+    )
+  }
+  const { lastParamComplete, params } = parsePartialJsonObjectSingle(content)
+  const lastParam = Object.keys(params).pop()
+
+  const { lastParamComplete: prevLastParamComplete, params: prevParams } =
+    parsePartialJsonObjectSingle(previous)
+  const prevLastParam = Object.keys(prevParams).pop()
+
+  const entries = Object.entries(params)
+
+  const delta: Record<string, any> = {}
+  for (const [key, value] of entries) {
+    if (prevParams[key] === value) {
+      if (prevLastParam === key && !prevLastParamComplete) {
+        delta[key] = ''
+      }
+      continue
+    }
+    if (typeof value === 'string') {
+      delta[key] = value.slice((prevParams[key] ?? '').length)
+    } else {
+      delta[key] = value
+    }
+  }
+
+  return {
+    delta,
+    result: params,
+    lastParam: {
+      key: lastParam,
+      complete:
+        prevLastParam === lastParam
+          ? lastParamComplete && !prevLastParamComplete
+          : lastParamComplete,
+    },
+  }
+}

package/vendor/@anvil/common/src/util/path.ts

@@ -0,0 +1,15 @@
+import path from 'path'
+
+/**
+ * True when candidate is lexically root itself or one of its descendants.
+ * Resolve symlinks first when the caller needs filesystem-level containment.
+ */
+export function isPathInside(root: string, candidate: string): boolean {
+  const relativePath = path.relative(root, candidate)
+  return (
+    relativePath === '' ||
+    (relativePath !== '..' &&
+      !relativePath.startsWith(`..${path.sep}`) &&
+      !path.isAbsolute(relativePath))
+  )
+}

package/vendor/@anvil/common/src/util/project-ignore.ts

@@ -0,0 +1,119 @@
+import * as ignore from 'ignore'
+
+export const PROJECT_IGNORE_FILES = [
+  '.gitignore',
+  '.anvilignore',
+  '.manicodeignore',
+  // Legacy: respect ignore files created by pre-Anvil installs.
+  '.codebuffignore',
+] as const
+
+export type DirIgnore = { base: string; ig: ignore.Ignore }
+
+function normalizeRelativePath(filePath: string): string | null {
+  const segments: string[] = []
+  for (const segment of filePath.replaceAll('\\', '/').split('/')) {
+    if (!segment || segment === '.') continue
+    if (segment === '..') {
+      if (segments.length === 0) return null
+      segments.pop()
+      continue
+    }
+    segments.push(segment)
+  }
+  return segments.join('/') || null
+}
+
+function testChain(chain: DirIgnore[], candidate: string): boolean {
+  let ignored = false
+  for (const { base, ig } of chain) {
+    if (base && !candidate.startsWith(`${base}/`)) continue
+    const scoped = base ? candidate.slice(base.length + 1) : candidate
+    if (!scoped) continue
+    const result = ig.test(scoped)
+    if (result.ignored) ignored = true
+    else if (result.unignored) ignored = false
+  }
+  return ignored
+}
+
+export function isIgnoredByIgnoreChain(
+  chain: DirIgnore[],
+  filePath: string,
+): boolean {
+  const segments = filePath.split('/')
+  for (let i = 0; i < segments.length - 1; i++) {
+    if (testChain(chain, `${segments.slice(0, i + 1).join('/')}/`)) {
+      return true
+    }
+  }
+  return testChain(chain, filePath)
+}
+
+export function addIgnoreFileContents(
+  ig: ignore.Ignore,
+  contents: string,
+  onInvalidPattern?: (pattern: string, error: unknown) => void,
+): void {
+  for (let line of contents.split('\n')) {
+    line = line.trim()
+    if (!line || line.startsWith('#')) continue
+    try {
+      ig.add(line)
+    } catch (error: unknown) {
+      // Match the local file-tree behavior: one invalid pattern must not make
+      // the remaining valid project rules disappear.
+      onInvalidPattern?.(line, error)
+    }
+  }
+}
+
+/**
+ * Build a fail-closed-friendly ignore-file reader for filesystems whose read
+ * errors do not reliably distinguish a missing file from an unreadable one.
+ */
+export function createProjectIgnoreFileReader(params: {
+  listDirectory: (directory: string) => Promise<readonly string[]>
+  readFile: (filePath: string) => Promise<string>
+}): (filePath: string) => Promise<string | null> {
+  const directoryEntries = new Map<string, Promise<Set<string>>>()
+
+  return async (filePath) => {
+    const separator = filePath.lastIndexOf('/')
+    const directory = separator === -1 ? '' : filePath.slice(0, separator)
+    const fileName = filePath.slice(separator + 1)
+
+    let entries = directoryEntries.get(directory)
+    if (!entries) {
+      entries = params.listDirectory(directory).then((names) => new Set(names))
+      directoryEntries.set(directory, entries)
+    }
+    if (!(await entries).has(fileName)) return null
+
+    return params.readFile(filePath)
+  }
+}
+
+/** Evaluate project-owned ignore files without requiring a native Git binary. */
+export async function isProjectFileIgnored(params: {
+  filePath: string
+  readIgnoreFile: (filePath: string) => Promise<string | null>
+}): Promise<boolean> {
+  const filePath = normalizeRelativePath(params.filePath)
+  if (!filePath) return true
+
+  const parentSegments = filePath.split('/').slice(0, -1)
+  const chain: DirIgnore[] = []
+  for (let depth = 0; depth <= parentSegments.length; depth++) {
+    const base = parentSegments.slice(0, depth).join('/')
+    const ig = ignore.default()
+    for (const ignoreFile of PROJECT_IGNORE_FILES) {
+      const ignorePath = base ? `${base}/${ignoreFile}` : ignoreFile
+      const contents = await params.readIgnoreFile(ignorePath)
+      if (contents !== null) addIgnoreFileContents(ig, contents)
+    }
+    chain.push({ base, ig })
+  }
+
+  return isIgnoredByIgnoreChain(chain, filePath)
+}

package/vendor/@anvil/common/src/util/promise.ts

@@ -0,0 +1,73 @@
+export const INITIAL_RETRY_DELAY = 1000 // 1 second
+
+export async function withRetry<T>(
+  operation: () => Promise<T>,
+  options: {
+    maxRetries?: number
+    retryIf?: (error: any) => boolean
+    onRetry?: (error: any, attempt: number) => void
+    retryDelayMs?: number
+  } = {},
+): Promise<T> {
+  const {
+    maxRetries = 3,
+    retryIf = (error) => error?.type === 'APIConnectionError',
+    onRetry = () => {},
+    retryDelayMs = INITIAL_RETRY_DELAY,
+  } = options
+
+  let lastError: any = null
+
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      return await operation()
+    } catch (error) {
+      lastError = error
+
+      if (!retryIf(error) || attempt === maxRetries - 1) {
+        throw error
+      }
+
+      onRetry(error, attempt + 1)
+
+      // Exponential backoff with jitter (±20%) to prevent thundering herd
+      const baseDelayMs = retryDelayMs * Math.pow(2, attempt)
+      const jitter = 0.8 + Math.random() * 0.4 // Random multiplier between 0.8 and 1.2
+      const delayMs = Math.round(baseDelayMs * jitter)
+      await new Promise((resolve) => setTimeout(resolve, delayMs))
+    }
+  }
+
+  throw lastError
+}
+
+export const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms))
+
+/**
+ * Wraps a promise with a timeout
+ * @param promise The promise to wrap
+ * @param timeoutMs Timeout in milliseconds
+ * @param timeoutMessage Optional message for the timeout error
+ * @returns A promise that resolves with the result of the original promise or rejects with a timeout error
+ */
+export async function withTimeout<T>(
+  promise: Promise<T>,
+  timeoutMs: number,
+  timeoutMessage: string = `Operation timed out after ${timeoutMs}ms`,
+): Promise<T> {
+  let timeoutId: ReturnType<typeof setTimeout> | undefined
+
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error(timeoutMessage))
+    }, timeoutMs)
+  })
+
+  try {
+    return await Promise.race([promise, timeoutPromise])
+  } finally {
+    if (timeoutId !== undefined) {
+      clearTimeout(timeoutId)
+    }
+  }
+}

package/vendor/@anvil/common/src/util/random.ts

@@ -0,0 +1,15 @@
+import seedrandom from 'seedrandom'
+
+export function sampleSizeWithSeed<T>(
+  array: T[],
+  size: number,
+  seed: string,
+): T[] {
+  const rng = seedrandom(seed)
+  const result = array.slice()
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1))
+    ;[result[i], result[j]] = [result[j], result[i]]
+  }
+  return result.slice(0, size)
+}

package/vendor/@anvil/common/src/util/rate-limit.ts

@@ -0,0 +1,56 @@
+/**
+ * Minimal in-memory fixed-window rate limiter, shared by the unauthenticated
+ * `/api/logs` ingest endpoints (browser + anonymous CLI). Per-instance and
+ * best-effort — good enough to blunt abuse/cost on a single Render instance,
+ * not a distributed guarantee. Kept dependency-free and `now`-injectable so the
+ * window logic is unit-testable.
+ */
+export interface FixedWindowRateLimiter {
+  /** Returns true if `key` has exceeded the window's request budget. */
+  limited(key: string, now: number): boolean
+}
+
+export function createFixedWindowRateLimiter(opts: {
+  windowMs: number
+  max: number
+  /** Prune expired entries once the map grows past this. Defaults to 10k. */
+  maxKeys?: number
+}): FixedWindowRateLimiter {
+  const { windowMs, max, maxKeys = 10_000 } = opts
+  const hits = new Map<string, { count: number; resetAt: number }>()
+  let lastPruneAt = 0
+
+  return {
+    limited(key: string, now: number): boolean {
+      const entry = hits.get(key)
+      if (!entry || now >= entry.resetAt) {
+        hits.set(key, { count: 1, resetAt: now + windowMs })
+        // Bound map growth: prune expired entries, but at most once per window
+        // so a steady stream of live keys can't trigger an O(n) scan per call.
+        if (hits.size > maxKeys && now - lastPruneAt >= windowMs) {
+          lastPruneAt = now
+          for (const [k, v] of hits) if (now >= v.resetAt) hits.delete(k)
+        }
+        return false
+      }
+      entry.count++
+      return entry.count > max
+    },
+  }
+}
+
+/**
+ * Best-effort client IP for per-IP rate limiting on the unauthenticated ingest
+ * endpoints. Prefers the proxy-set `x-real-ip` (harder to spoof than the
+ * left-most `x-forwarded-for` token). Accepts any Headers-like object so it
+ * works with `NextRequest.headers` without a Next dependency here.
+ */
+export function extractClientIp(headers: {
+  get(name: string): string | null
+}): string {
+  return (
+    headers.get('x-real-ip')?.trim() ||
+    headers.get('x-forwarded-for')?.split(',')[0]?.trim() ||
+    'unknown'
+  )
+}

package/vendor/@anvil/common/src/util/reddit-anvil-retention.ts

@@ -0,0 +1,60 @@
+const DAY_MS = 24 * 60 * 60 * 1000
+
+/** PostHog-style retention windows to mirror in Reddit CAPI custom events. */
+export const ANVIL_REDDIT_RETENTION_MILESTONE_DAYS = [1, 7, 24] as const
+
+export type AnvilRedditRetentionMilestoneDays =
+  (typeof ANVIL_REDDIT_RETENTION_MILESTONE_DAYS)[number]
+
+export type AnvilRedditConversionPlan = {
+  fireFirstPrompt: boolean
+  retentionMilestones: AnvilRedditRetentionMilestoneDays[]
+}
+
+function daysBetween(fromDateKey: string, toDateKey: string): number {
+  const from = new Date(`${fromDateKey}T00:00:00.000Z`).getTime()
+  const to = new Date(`${toDateKey}T00:00:00.000Z`).getTime()
+  if (Number.isNaN(from) || Number.isNaN(to)) {
+    throw new Error(`Invalid date key range: ${fromDateKey} -> ${toDateKey}`)
+  }
+  return Math.round((to - from) / DAY_MS)
+}
+
+/** First successful anvil prompt = first-ever usage day recorded. */
+export function isFirstAnvilPrompt(params: {
+  previousUsageDays: readonly string[]
+  newUsageDayRecorded: boolean
+}): boolean {
+  return params.newUsageDayRecorded && params.previousUsageDays.length === 0
+}
+
+/** Exact calendar-day milestones reached by this newly recorded usage day. */
+export function getAnvilRetentionMilestonesToFire(params: {
+  previousUsageDays: readonly string[]
+  todayDateKey: string
+  newUsageDayRecorded: boolean
+}): AnvilRedditRetentionMilestoneDays[] {
+  if (!params.newUsageDayRecorded) {
+    return []
+  }
+
+  const firstDay = [...params.previousUsageDays, params.todayDateKey].reduce(
+    (min, dateKey) => (dateKey < min ? dateKey : min),
+  )
+  const daysSinceFirstToday = daysBetween(firstDay, params.todayDateKey)
+
+  return ANVIL_REDDIT_RETENTION_MILESTONE_DAYS.filter(
+    (milestone) => daysSinceFirstToday === milestone,
+  )
+}
+
+export function planAnvilRedditConversionEvents(params: {
+  previousUsageDays: readonly string[]
+  todayDateKey: string
+  newUsageDayRecorded: boolean
+}): AnvilRedditConversionPlan {
+  return {
+    fireFirstPrompt: isFirstAnvilPrompt(params),
+    retentionMilestones: getAnvilRetentionMilestonesToFire(params),
+  }
+}

package/vendor/@anvil/common/src/util/reddit-capi-events.ts

@@ -0,0 +1,36 @@
+import type { AnvilRedditRetentionMilestoneDays } from '@anvil/common/util/reddit-anvil-retention'
+
+export type RedditConversionSurface = 'cli' | 'web' | 'cloud' | 'chat'
+
+export type RedditCapiEventName =
+  | 'FirstPrompt'
+  | 'Retention1d'
+  | 'Retention7d'
+  | 'Retention24d'
+
+export const REDDIT_FIRST_PROMPT_EVENT = 'FirstPrompt' as const
+
+export function redditRetentionCapiEventName(
+  milestone: AnvilRedditRetentionMilestoneDays,
+): RedditCapiEventName {
+  return `Retention${milestone}d`
+}
+
+/**
+ * The day boundary D1/D7/D24 eligibility is computed in.
+ *
+ * Anything deciding "have we already done this user's tracking today?" MUST
+ * use this same boundary. A memo keyed on a different day (Pacific, say) opens
+ * a window where the UTC day has rolled over but the memo has not, and a
+ * milestone claim can never be created in it — the conversion is lost, not
+ * delayed. Do not reimplement.
+ *
+ * It lives in this dependency-free module rather than next to its consumer in
+ * `packages/internal/src/reddit-conversions.ts`, because that module imports
+ * `./db`, which constructs the application connection pool at module scope.
+ * A pure date helper must not drag a database pool into everything that needs
+ * a day key.
+ */
+export function utcDateKey(now: Date): string {
+  return now.toISOString().slice(0, 10)
+}