@nathanvale/chatline 0.2.1 → 0.3.0

package/dist/index.js

@@ -0,0 +1,1729 @@
+// src/config/generator.ts
+import { constants } from "node:fs";
+import { access, writeFile } from "node:fs/promises";
+import yaml from "js-yaml";
+
+// src/config/schema.ts
+import { z } from "zod";
+var GeminiConfigSchema = z.object({
+  apiKey: z.string().min(1, "Gemini API key is required"),
+  model: z.string().default("gemini-1.5-pro"),
+  rateLimitDelay: z.number().min(0).default(1000),
+  maxRetries: z.number().min(0).max(10).default(3)
+});
+var FirecrawlConfigSchema = z.object({
+  apiKey: z.string().optional(),
+  enabled: z.boolean().default(true)
+}).optional();
+var EnrichmentConfigSchema = z.object({
+  enableVisionAnalysis: z.boolean().default(true),
+  enableAudioTranscription: z.boolean().default(true),
+  enableLinkEnrichment: z.boolean().default(true),
+  imageCacheDir: z.string().default("./.cache/images"),
+  checkpointInterval: z.number().min(1).max(1e4).default(100),
+  forceRefresh: z.boolean().default(false)
+});
+var RenderConfigSchema = z.object({
+  groupByTimeOfDay: z.boolean().default(true),
+  renderRepliesAsNested: z.boolean().default(true),
+  renderTapbacksAsEmoji: z.boolean().default(true),
+  maxNestingDepth: z.number().min(1).max(100).default(10)
+});
+var ConfigSchema = z.object({
+  version: z.string().default("1.0"),
+  attachmentRoots: z.array(z.string().min(1, "Attachment root path cannot be empty")).min(1, "At least one attachment root is required").default(["~/Library/Messages/Attachments"]),
+  gemini: GeminiConfigSchema,
+  firecrawl: FirecrawlConfigSchema,
+  enrichment: EnrichmentConfigSchema.default({
+    enableVisionAnalysis: true,
+    enableAudioTranscription: true,
+    enableLinkEnrichment: true,
+    imageCacheDir: "./.cache/images",
+    checkpointInterval: 100,
+    forceRefresh: false
+  }),
+  render: RenderConfigSchema.default({
+    groupByTimeOfDay: true,
+    renderRepliesAsNested: true,
+    renderTapbacksAsEmoji: true,
+    maxNestingDepth: 10
+  })
+});
+function validateConfig(config) {
+  return ConfigSchema.parse(config);
+}
+function validateConfigSafe(config) {
+  const result = ConfigSchema.safeParse(config);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return {
+    success: false,
+    errors: result.error.errors.map((err) => ({
+      path: err.path.join("."),
+      message: err.message
+    }))
+  };
+}
+var DEFAULT_CONFIG = {
+  version: "1.0",
+  attachmentRoots: ["~/Library/Messages/Attachments"],
+  enrichment: {
+    enableVisionAnalysis: true,
+    enableAudioTranscription: true,
+    enableLinkEnrichment: true,
+    imageCacheDir: "./.cache/images",
+    checkpointInterval: 100,
+    forceRefresh: false
+  },
+  render: {
+    groupByTimeOfDay: true,
+    renderRepliesAsNested: true,
+    renderTapbacksAsEmoji: true,
+    maxNestingDepth: 10
+  }
+};
+var CONFIG_FILE_PATTERNS = [
+  "./imessage-config.yaml",
+  "./imessage-config.yml",
+  "./imessage-config.json"
+];
+function detectConfigFormat(filePath) {
+  if (filePath.endsWith(".json")) {
+    return "json";
+  }
+  if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
+    return "yaml";
+  }
+  throw new Error(`Unsupported config file format: ${filePath}. Supported formats: .json, .yaml, .yml`);
+}
+
+// src/config/generator.ts
+var CONFIG_TEMPLATE_WITH_DOCS = `# iMessage Timeline Configuration File
+# Generated by: chatline init
+#
+# This file configures the iMessage message export and enrichment pipeline.
+# Supports both YAML and JSON formats with environment variable substitution.
+
+# Schema version (for future migrations)
+version: "1.0"
+
+# ============================================================================
+# Attachment Resolution
+# ============================================================================
+
+# Directories to search for message attachments
+# Multiple paths supported; first match wins
+# Environment variable expansion supported: \${HOME}/Library/Messages
+attachmentRoots:
+  - "~/Library/Messages/Attachments"
+  # Add additional search paths if needed:
+  # - "/path/to/imazing/backup/attachments"
+
+# ============================================================================
+# Gemini AI Configuration
+# ============================================================================
+
+gemini:
+  # Google Gemini API key (required for AI enrichment)
+  # Get your key from: https://makersuite.google.com/app/apikey
+  # Environment variable recommended for security: \${GEMINI_API_KEY}
+  apiKey: "\${GEMINI_API_KEY}"
+
+  # Gemini model to use for enrichment
+  # Options: gemini-1.5-pro, gemini-1.5-flash
+  # Default: gemini-1.5-pro (more accurate, slower)
+  model: "gemini-1.5-pro"
+
+  # Delay between API calls (milliseconds)
+  # Prevents rate limiting; adjust based on your quota
+  # Free tier: 60 requests/minute = 1000ms delay minimum
+  # Default: 1000 (1 second)
+  rateLimitDelay: 1000
+
+  # Maximum retries for failed API calls
+  # Applies exponential backoff with jitter
+  # Range: 0-10
+  # Default: 3
+  maxRetries: 3
+
+# ============================================================================
+# Firecrawl Configuration (Optional)
+# ============================================================================
+
+# firecrawl:
+#   # Firecrawl API key for enhanced link scraping (optional)
+#   # Get your key from: https://firecrawl.dev
+#   # Falls back to built-in scrapers if not provided
+#   apiKey: "\${FIRECRAWL_API_KEY}"
+#
+#   # Enable/disable Firecrawl for link enrichment
+#   # Default: true (if apiKey provided)
+#   enabled: true
+
+# ============================================================================
+# Enrichment Pipeline Configuration
+# ============================================================================
+
+enrichment:
+  # Enable image analysis (captions, descriptions via Gemini Vision)
+  # HEIC/TIFF files converted to JPG for analysis
+  # Default: true
+  enableVisionAnalysis: true
+
+  # Enable audio transcription (voice memos, audio messages)
+  # Includes timestamps, speaker detection, and summaries
+  # Default: true
+  enableAudioTranscription: true
+
+  # Enable link context extraction (titles, summaries, metadata)
+  # Uses Firecrawl if configured, falls back to built-in scrapers
+  # Default: true
+  enableLinkEnrichment: true
+
+  # Cache directory for image previews (HEIC/TIFF → JPG)
+  # Prevents redundant conversions on re-runs
+  # Default: ./.cache/images
+  imageCacheDir: "./.cache/images"
+
+  # Checkpoint interval (messages per checkpoint)
+  # Lower = more frequent checkpoints = safer but slower
+  # Higher = faster but more work lost on interruption
+  # Range: 1-10000
+  # Default: 100
+  checkpointInterval: 100
+
+  # Force refresh of existing enrichments
+  # If true, re-enriches messages even if already enriched
+  # Default: false (skip already-enriched messages)
+  forceRefresh: false
+
+# ============================================================================
+# Markdown Rendering Configuration
+# ============================================================================
+
+render:
+  # Group messages by time-of-day (Morning, Afternoon, Evening)
+  # If false, renders as flat chronological list
+  # Default: true
+  groupByTimeOfDay: true
+
+  # Render replies as nested blockquotes under parent message
+  # If false, renders as flat list with reply indicators
+  # Default: true
+  renderRepliesAsNested: true
+
+  # Render tapbacks (reactions) as emoji (❤️, \uD83D\uDE02, etc.)
+  # If false, renders as text descriptions
+  # Default: true
+  renderTapbacksAsEmoji: true
+
+  # Maximum nesting depth for nested replies
+  # Prevents infinite recursion in circular reply chains
+  # Range: 1-100
+  # Default: 10
+  maxNestingDepth: 10
+`;
+var CONFIG_TEMPLATE_JSON = {
+  _comment: "iMessage Timeline Configuration File",
+  _generated: "Generated by: chatline init",
+  _docs: "Full documentation: https://github.com/your-repo/chatline",
+  version: "1.0",
+  attachmentRoots: ["~/Library/Messages/Attachments"],
+  gemini: {
+    _comment: "Get API key from: https://makersuite.google.com/app/apikey",
+    apiKey: "${GEMINI_API_KEY}",
+    model: "gemini-1.5-pro",
+    rateLimitDelay: 1000,
+    maxRetries: 3
+  },
+  enrichment: {
+    enableVisionAnalysis: true,
+    enableAudioTranscription: true,
+    enableLinkEnrichment: true,
+    imageCacheDir: "./.cache/images",
+    checkpointInterval: 100,
+    forceRefresh: false
+  },
+  render: {
+    groupByTimeOfDay: true,
+    renderRepliesAsNested: true,
+    renderTapbacksAsEmoji: true,
+    maxNestingDepth: 10
+  }
+};
+function generateConfigContent(format) {
+  if (format === "yaml") {
+    return CONFIG_TEMPLATE_WITH_DOCS;
+  }
+  return `${JSON.stringify(CONFIG_TEMPLATE_JSON, null, 2)}
+`;
+}
+function validateGeneratedConfig(content, format) {
+  try {
+    let parsed;
+    if (format === "json") {
+      parsed = JSON.parse(content);
+    } else {
+      parsed = yaml.load(content);
+    }
+    validateConfig(parsed);
+    return { valid: true };
+  } catch (error) {
+    if (error instanceof Error) {
+      return {
+        valid: false,
+        errors: [error.message]
+      };
+    }
+    return {
+      valid: false,
+      errors: ["Unknown validation error"]
+    };
+  }
+}
+function getDefaultConfigPath(format) {
+  return format === "yaml" ? "./imessage-config.yaml" : "./imessage-config.json";
+}
+// src/config/loader.ts
+import { constants as constants2 } from "node:fs";
+import { access as access2, readFile } from "node:fs/promises";
+import yaml2 from "js-yaml";
+var configCache = null;
+var configCachePath = null;
+async function discoverConfigFile(baseDir = process.cwd()) {
+  const fileNames = [
+    "imessage-config.yaml",
+    "imessage-config.yml",
+    "imessage-config.json"
+  ];
+  for (const fileName of fileNames) {
+    const filePath = baseDir.startsWith("/") ? `${baseDir}/${fileName}` : `./${baseDir}/${fileName}`.replace(/\/\.\//g, "/");
+    try {
+      await access2(filePath, constants2.R_OK);
+      return filePath;
+    } catch {}
+  }
+  return null;
+}
+async function loadConfigFile(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  const format = detectConfigFormat(filePath);
+  if (format === "json") {
+    try {
+      return JSON.parse(content);
+    } catch (error) {
+      throw new Error(`Failed to parse JSON config file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  } else if (format === "yaml") {
+    try {
+      return yaml2.load(content, { schema: yaml2.JSON_SCHEMA });
+    } catch (error) {
+      throw new Error(`Failed to parse YAML config file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  throw new Error(`Unsupported config format: ${filePath}`);
+}
+function substituteEnvVars(obj) {
+  if (typeof obj === "string") {
+    return obj.replace(/\$\{(\w+)\}/g, (_match, envVar) => {
+      const value = process.env[envVar];
+      if (value === undefined) {
+        throw new Error(`Environment variable ${envVar} is not set but referenced in config`);
+      }
+      return value;
+    });
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(substituteEnvVars);
+  }
+  if (typeof obj === "object" && obj !== null) {
+    return Object.fromEntries(Object.entries(obj).map(([key, value]) => [
+      key,
+      substituteEnvVars(value)
+    ]));
+  }
+  return obj;
+}
+function mergeConfig(fileConfig, cliOptions = {}) {
+  const merged = {
+    ...fileConfig,
+    ...cliOptions
+  };
+  if (fileConfig.gemini || cliOptions.gemini) {
+    merged.gemini = {
+      ...fileConfig.gemini,
+      ...cliOptions.gemini
+    };
+  }
+  if (cliOptions.firecrawl !== undefined) {
+    merged.firecrawl = cliOptions.firecrawl;
+  } else if (fileConfig.firecrawl !== undefined) {
+    merged.firecrawl = fileConfig.firecrawl;
+  }
+  if (fileConfig.enrichment || cliOptions.enrichment) {
+    merged.enrichment = {
+      ...fileConfig.enrichment,
+      ...cliOptions.enrichment
+    };
+  }
+  if (fileConfig.render || cliOptions.render) {
+    merged.render = {
+      ...fileConfig.render,
+      ...cliOptions.render
+    };
+  }
+  return merged;
+}
+async function loadConfig(options = {}) {
+  const { configPath, cliOptions = {}, skipCache = false } = options;
+  if (!skipCache && configCache && configCachePath === configPath) {
+    return configCache;
+  }
+  const filePath = configPath || await discoverConfigFile();
+  let fileConfig = {};
+  if (filePath) {
+    try {
+      const rawConfig = await loadConfigFile(filePath);
+      const withEnvVars = substituteEnvVars(rawConfig);
+      fileConfig = withEnvVars;
+    } catch (error) {
+      throw new Error(`Failed to load config from ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  const merged = mergeConfig(fileConfig, cliOptions);
+  try {
+    const validated = validateConfig(merged);
+    configCache = validated;
+    configCachePath = configPath || null;
+    return validated;
+  } catch (error) {
+    throw new Error(`Config validation failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function clearConfigCache() {
+  configCache = null;
+  configCachePath = null;
+}
+function isConfigCached() {
+  return configCache !== null;
+}
+// src/enrich/rate-limiting.ts
+class RateLimiter {
+  config;
+  state;
+  constructor(partialConfig) {
+    this.config = {
+      rateLimitDelay: partialConfig?.rateLimitDelay ?? 1000,
+      maxRetries: partialConfig?.maxRetries ?? 3,
+      circuitBreakerThreshold: partialConfig?.circuitBreakerThreshold ?? 5,
+      circuitBreakerResetMs: partialConfig?.circuitBreakerResetMs ?? 60000
+    };
+    this.validateConfig(this.config);
+    this.state = {
+      consecutiveFailures: 0,
+      circuitOpen: false,
+      circuitOpenedAt: null,
+      lastCallTime: null
+    };
+  }
+  validateConfig(config) {
+    if (config.rateLimitDelay < 0)
+      throw new Error("rateLimitDelay must be non-negative");
+    if (config.maxRetries < 0)
+      throw new Error("maxRetries must be non-negative");
+    if (config.circuitBreakerThreshold < 1)
+      throw new Error("circuitBreakerThreshold must be >= 1");
+    if (config.circuitBreakerResetMs < 0)
+      throw new Error("circuitBreakerResetMs must be non-negative");
+  }
+  shouldRateLimit() {
+    if (this.state.lastCallTime === null) {
+      return 0;
+    }
+    const timeSinceLastCall = Date.now() - this.state.lastCallTime;
+    const requiredDelay = this.config.rateLimitDelay;
+    if (timeSinceLastCall < requiredDelay) {
+      return requiredDelay - timeSinceLastCall;
+    }
+    return 0;
+  }
+  recordCall() {
+    this.state.lastCallTime = Date.now();
+  }
+  calculateExponentialBackoff(attemptNumber) {
+    const baseDelaySeconds = 2 ** attemptNumber;
+    const baseDelayMs = baseDelaySeconds * 1000;
+    const jitterAmount = baseDelayMs * 0.25;
+    const jitter = (Math.random() - 0.5) * 2 * jitterAmount;
+    return baseDelayMs + jitter;
+  }
+  parseRetryAfterHeader(retryAfterValue) {
+    if (retryAfterValue === undefined || retryAfterValue === null) {
+      return null;
+    }
+    if (typeof retryAfterValue === "number") {
+      return retryAfterValue * 1000;
+    }
+    const strValue = String(retryAfterValue).trim();
+    const seconds = Number.parseInt(strValue, 10);
+    if (!Number.isNaN(seconds) && seconds >= 0) {
+      return seconds * 1000;
+    }
+    try {
+      const date = new Date(strValue);
+      if (!Number.isNaN(date.getTime())) {
+        const delayMs = date.getTime() - Date.now();
+        return Math.max(0, delayMs);
+      }
+    } catch {}
+    return null;
+  }
+  getRetryStrategy(response, attemptNumber) {
+    const { status, headers } = response;
+    if (status >= 200 && status < 300) {
+      return { shouldRetry: false, delayMs: 0 };
+    }
+    const isRetryableStatus = status === 429 || status >= 500 && status < 600;
+    if (!isRetryableStatus) {
+      return { shouldRetry: false, delayMs: 0 };
+    }
+    const retryAfterMs = this.parseRetryAfterHeader(headers?.["Retry-After"]);
+    if (retryAfterMs !== null) {
+      return { shouldRetry: true, delayMs: retryAfterMs };
+    }
+    const backoffMs = this.calculateExponentialBackoff(attemptNumber);
+    return { shouldRetry: true, delayMs: backoffMs };
+  }
+  shouldRetryAttempt(attemptNumber) {
+    return attemptNumber <= this.config.maxRetries;
+  }
+  isCircuitOpen() {
+    if (!this.state.circuitOpen) {
+      return false;
+    }
+    const timeSinceOpened = Date.now() - (this.state.circuitOpenedAt ?? 0);
+    if (timeSinceOpened >= this.config.circuitBreakerResetMs) {
+      this.resetCircuitBreaker();
+      return false;
+    }
+    return true;
+  }
+  recordFailure() {
+    this.state.consecutiveFailures += 1;
+    if (this.state.consecutiveFailures >= this.config.circuitBreakerThreshold) {
+      this.state.circuitOpen = true;
+      this.state.circuitOpenedAt = Date.now();
+    }
+  }
+  recordSuccess() {
+    this.state.consecutiveFailures = 0;
+    this.state.circuitOpen = false;
+    this.state.circuitOpenedAt = null;
+  }
+  resetCircuitBreaker() {
+    this.state.consecutiveFailures = 0;
+    this.state.circuitOpen = false;
+    this.state.circuitOpenedAt = null;
+  }
+  getState() {
+    return { ...this.state };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  reset() {
+    this.state = {
+      consecutiveFailures: 0,
+      circuitOpen: false,
+      circuitOpenedAt: null,
+      lastCallTime: null
+    };
+  }
+}
+function createRateLimiter(config) {
+  return new RateLimiter(config);
+}
+function is5xx(status) {
+  return status >= 500 && status < 600;
+}
+function isRetryableStatus(status) {
+  return status === 429 || is5xx(status);
+}
+// src/ingest/dedup-merge.ts
+function dedupAndMerge(csvMessages, dbMessages) {
+  const sortedCsv = [...csvMessages].sort((a, b) => a.guid.localeCompare(b.guid));
+  const sortedDb = [...dbMessages].sort((a, b) => a.guid.localeCompare(b.guid));
+  const stats = {
+    csvCount: csvMessages.length,
+    dbCount: dbMessages.length,
+    outputCount: 0,
+    exactMatches: 0,
+    contentMatches: 0,
+    conflicts: 0,
+    noMatches: 0
+  };
+  const outputMessages = [];
+  const matchedDbGuids = new Set;
+  const dbByGuid = new Map;
+  const dbByNormalizedContent = new Map;
+  for (const dbMsg of sortedDb) {
+    dbByGuid.set(dbMsg.guid, dbMsg);
+    if (dbMsg.messageKind === "text" && dbMsg.text) {
+      const normalizedKey = `${dbMsg.handle || ""}:${normalizeTextForIndex(dbMsg.text)}`;
+      const existing = dbByNormalizedContent.get(normalizedKey);
+      if (existing) {
+        existing.push(dbMsg);
+      } else {
+        dbByNormalizedContent.set(normalizedKey, [dbMsg]);
+      }
+    }
+  }
+  for (const csvMsg of sortedCsv) {
+    const exactMatch = dbByGuid.get(csvMsg.guid) || null;
+    if (exactMatch) {
+      const merged = applyDbAuthoritiveness(csvMsg, exactMatch);
+      outputMessages.push(merged);
+      matchedDbGuids.add(exactMatch.guid);
+      stats.exactMatches++;
+    } else {
+      let contentMatch = detectContentEquivalenceIndexed(csvMsg, dbByNormalizedContent, matchedDbGuids);
+      if (!contentMatch && csvMsg.messageKind !== "text") {
+        const unmatchedDbMessages = sortedDb.filter((dbMsg) => !matchedDbGuids.has(dbMsg.guid));
+        contentMatch = detectContentEquivalence(csvMsg, unmatchedDbMessages);
+      }
+      if (contentMatch) {
+        const merged = applyDbAuthoritiveness(csvMsg, contentMatch.message);
+        outputMessages.push(merged);
+        matchedDbGuids.add(contentMatch.message.guid);
+        stats.contentMatches++;
+      } else {
+        outputMessages.push(csvMsg);
+        stats.noMatches++;
+      }
+    }
+  }
+  for (const dbMsg of sortedDb) {
+    if (!matchedDbGuids.has(dbMsg.guid)) {
+      outputMessages.push(dbMsg);
+    }
+  }
+  stats.outputCount = outputMessages.length;
+  return {
+    messages: outputMessages,
+    stats
+  };
+}
+function detectContentEquivalence(csvMsg, candidates, threshold = 0.9) {
+  for (const candidate of candidates) {
+    const reasons = [];
+    let confidence = 0;
+    if (csvMsg.messageKind !== candidate.messageKind) {
+      continue;
+    }
+    const csvHandle = csvMsg.handle || null;
+    const candidateHandle = candidate.handle || null;
+    if (csvHandle !== candidateHandle) {
+      continue;
+    }
+    if (csvMsg.messageKind === "text" && candidate.messageKind === "text") {
+      const csvText = normalizeText(csvMsg.text || "");
+      const candidateText = normalizeText(candidate.text || "");
+      if (csvText === candidateText) {
+        confidence = 1;
+        reasons.push("exact text match after normalization");
+      } else {
+        continue;
+      }
+    } else if (csvMsg.messageKind === "media" && candidate.messageKind === "media") {
+      const csvMediaId = csvMsg.media?.id;
+      const candidateMediaId = candidate.media?.id;
+      if (csvMediaId && candidateMediaId && csvMediaId === candidateMediaId) {
+        confidence = 1;
+        reasons.push("exact media ID match");
+      } else {
+        continue;
+      }
+    } else {
+      continue;
+    }
+    if (confidence >= threshold) {
+      return {
+        message: candidate,
+        confidence,
+        reasons
+      };
+    }
+  }
+  return null;
+}
+function normalizeText(text) {
+  return text.toLowerCase().trim().replace(/[^\w\s]/g, "").replace(/\s+/g, " ").trim();
+}
+function normalizeTextForIndex(text) {
+  return normalizeText(text);
+}
+function detectContentEquivalenceIndexed(csvMsg, contentIndex, matchedGuids) {
+  if (csvMsg.messageKind !== "text" || !csvMsg.text) {
+    return null;
+  }
+  const normalizedKey = `${csvMsg.handle || ""}:${normalizeTextForIndex(csvMsg.text)}`;
+  const candidates = contentIndex.get(normalizedKey);
+  if (!candidates || candidates.length === 0) {
+    return null;
+  }
+  for (const candidate of candidates) {
+    if (!matchedGuids.has(candidate.guid)) {
+      return {
+        message: candidate,
+        confidence: 1,
+        reasons: ["exact text match after normalization (indexed)"]
+      };
+    }
+  }
+  return null;
+}
+function applyDbAuthoritiveness(csvMsg, dbMsg) {
+  const merged = { ...csvMsg };
+  merged.date = dbMsg.date;
+  if (dbMsg.dateRead !== undefined)
+    merged.dateRead = dbMsg.dateRead;
+  if (dbMsg.dateDelivered !== undefined)
+    merged.dateDelivered = dbMsg.dateDelivered;
+  if (dbMsg.dateEdited !== undefined)
+    merged.dateEdited = dbMsg.dateEdited;
+  if (dbMsg.handle !== undefined)
+    merged.handle = dbMsg.handle;
+  if (dbMsg.replyingTo?.targetMessageGuid !== undefined) {
+    merged.replyingTo = {
+      ...merged.replyingTo,
+      targetMessageGuid: dbMsg.replyingTo.targetMessageGuid
+    };
+  }
+  if (dbMsg.isRead !== undefined)
+    merged.isRead = dbMsg.isRead;
+  merged.guid = dbMsg.guid;
+  return merged;
+}
+// src/ingest/ingest-csv.ts
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { parse } from "csv-parse/sync";
+
+// src/schema/message.ts
+import { z as z2 } from "zod";
+var MediaEnrichmentSchema = z2.object({
+  kind: z2.enum([
+    "image",
+    "audio",
+    "link",
+    "video",
+    "pdf",
+    "unknown",
+    "transcription",
+    "pdf_summary",
+    "video_metadata",
+    "link_context",
+    "image_analysis"
+  ]),
+  model: z2.string().optional(),
+  createdAt: z2.string().datetime(),
+  visionSummary: z2.string().optional(),
+  shortDescription: z2.string().optional(),
+  transcription: z2.string().optional(),
+  transcript: z2.string().optional(),
+  speakers: z2.array(z2.string()).optional(),
+  timestamps: z2.array(z2.object({
+    time: z2.string(),
+    speaker: z2.string(),
+    content: z2.string()
+  })).optional(),
+  pdfSummary: z2.string().optional(),
+  videoMetadata: z2.object({
+    filename: z2.string().optional(),
+    size: z2.number().optional(),
+    duration: z2.number().optional(),
+    analyzed: z2.boolean().optional(),
+    note: z2.string().optional()
+  }).optional(),
+  error: z2.string().optional(),
+  usedFallback: z2.boolean().optional(),
+  failedProviders: z2.array(z2.string()).optional(),
+  url: z2.string().url().optional(),
+  title: z2.string().optional(),
+  summary: z2.string().optional(),
+  provider: z2.enum([
+    "gemini",
+    "firecrawl",
+    "local",
+    "youtube",
+    "spotify",
+    "twitter",
+    "instagram",
+    "generic"
+  ]),
+  version: z2.string()
+}).superRefine((enrichment, ctx) => {
+  if (enrichment.createdAt && !enrichment.createdAt.match(/Z$/)) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "enrichment.createdAt must be ISO 8601 with Z suffix (UTC)"
+    });
+  }
+});
+var MediaProvenanceSchema = z2.object({
+  source: z2.enum(["csv", "db", "merged"]),
+  lastSeen: z2.string().datetime(),
+  resolvedAt: z2.string().datetime()
+}).superRefine((prov, ctx) => {
+  if (prov.lastSeen && !prov.lastSeen.match(/Z$/)) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "lastSeen must be ISO 8601 with Z suffix (UTC)",
+      path: ["lastSeen"]
+    });
+  }
+  if (prov.resolvedAt && !prov.resolvedAt.match(/Z$/)) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "resolvedAt must be ISO 8601 with Z suffix (UTC)",
+      path: ["resolvedAt"]
+    });
+  }
+});
+var MediaMetaSchema = z2.object({
+  id: z2.string(),
+  filename: z2.string(),
+  path: z2.string(),
+  size: z2.number().optional(),
+  mimeType: z2.string().optional(),
+  uti: z2.string().nullable().optional(),
+  isSticker: z2.boolean().optional(),
+  hidden: z2.boolean().optional(),
+  mediaKind: z2.enum(["image", "audio", "video", "pdf", "unknown"]).optional(),
+  enrichment: z2.array(MediaEnrichmentSchema).optional(),
+  provenance: MediaProvenanceSchema.optional()
+}).superRefine((media, ctx) => {
+  if (media.path && !media.path.startsWith("/")) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "media.path must be an absolute path (starting with /)",
+      path: ["path"]
+    });
+  }
+});
+var ReplyInfoSchema = z2.object({
+  sender: z2.string().optional(),
+  date: z2.string().datetime().optional(),
+  text: z2.string().optional(),
+  targetMessageGuid: z2.string().optional()
+}).superRefine((reply, ctx) => {
+  if (reply.date) {
+    if (!reply.date.match(/Z$/)) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: "replyingTo.date must be ISO 8601 with Z suffix (UTC)",
+        path: ["date"]
+      });
+    }
+    if (Number.isNaN(Date.parse(reply.date))) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: "replyingTo.date must be a valid ISO 8601 date",
+        path: ["date"]
+      });
+    }
+  }
+});
+var TapbackInfoSchema = z2.object({
+  type: z2.enum([
+    "loved",
+    "liked",
+    "disliked",
+    "laughed",
+    "emphasized",
+    "questioned",
+    "emoji"
+  ]),
+  action: z2.enum(["added", "removed"]),
+  targetMessageGuid: z2.string().optional(),
+  targetMessagePart: z2.number().int().optional(),
+  targetText: z2.string().optional(),
+  isMedia: z2.boolean().optional(),
+  emoji: z2.string().optional()
+});
+var MessageCoreSchema = z2.object({
+  guid: z2.string(),
+  rowid: z2.number().optional(),
+  chatId: z2.string().nullable().optional(),
+  service: z2.string().nullable().optional(),
+  subject: z2.string().nullable().optional(),
+  handleId: z2.number().nullable().optional(),
+  handle: z2.string().nullable().optional(),
+  destinationCallerId: z2.string().nullable().optional(),
+  isFromMe: z2.boolean(),
+  otherHandle: z2.number().nullable().optional(),
+  date: z2.string().datetime(),
+  dateRead: z2.string().datetime().nullable().optional(),
+  dateDelivered: z2.string().datetime().nullable().optional(),
+  dateEdited: z2.string().datetime().nullable().optional(),
+  isRead: z2.boolean().optional(),
+  itemType: z2.number().optional(),
+  groupActionType: z2.number().optional(),
+  groupTitle: z2.string().nullable().optional(),
+  shareStatus: z2.boolean().optional(),
+  shareDirection: z2.boolean().nullable().optional(),
+  expressiveSendStyleId: z2.string().nullable().optional(),
+  balloonBundleId: z2.string().nullable().optional(),
+  threadOriginatorGuid: z2.string().nullable().optional(),
+  threadOriginatorPart: z2.number().nullable().optional(),
+  numReplies: z2.number().optional(),
+  deletedFrom: z2.number().nullable().optional()
+});
+var MessageSchema = z2.object({
+  guid: z2.string(),
+  rowid: z2.number().optional(),
+  chatId: z2.string().nullable().optional(),
+  service: z2.string().nullable().optional(),
+  subject: z2.string().nullable().optional(),
+  handleId: z2.number().nullable().optional(),
+  handle: z2.string().nullable().optional(),
+  destinationCallerId: z2.string().nullable().optional(),
+  isFromMe: z2.boolean(),
+  otherHandle: z2.number().nullable().optional(),
+  date: z2.string().datetime(),
+  dateRead: z2.string().datetime().nullable().optional(),
+  dateDelivered: z2.string().datetime().nullable().optional(),
+  dateEdited: z2.string().datetime().nullable().optional(),
+  isRead: z2.boolean().optional(),
+  itemType: z2.number().optional(),
+  groupActionType: z2.number().optional(),
+  groupTitle: z2.string().nullable().optional(),
+  shareStatus: z2.boolean().optional(),
+  shareDirection: z2.boolean().nullable().optional(),
+  expressiveSendStyleId: z2.string().nullable().optional(),
+  balloonBundleId: z2.string().nullable().optional(),
+  threadOriginatorGuid: z2.string().nullable().optional(),
+  threadOriginatorPart: z2.number().nullable().optional(),
+  numReplies: z2.number().optional(),
+  deletedFrom: z2.number().nullable().optional(),
+  messageKind: z2.enum(["text", "media", "tapback", "notification"]),
+  text: z2.string().nullable().optional(),
+  tapback: TapbackInfoSchema.nullable().optional(),
+  replyingTo: ReplyInfoSchema.nullable().optional(),
+  replyingToRaw: z2.string().nullable().optional(),
+  media: MediaMetaSchema.nullable().optional(),
+  groupGuid: z2.string().nullable().optional(),
+  exportTimestamp: z2.string().datetime().optional(),
+  exportVersion: z2.string().optional(),
+  isUnsent: z2.boolean().optional(),
+  isEdited: z2.boolean().optional()
+}).superRefine((msg, ctx) => {
+  const dateFields = [
+    "date",
+    "dateRead",
+    "dateDelivered",
+    "dateEdited",
+    "exportTimestamp"
+  ];
+  for (const field of dateFields) {
+    const value = msg[field];
+    if (value && typeof value === "string") {
+      if (!value.match(/Z$/)) {
+        ctx.addIssue({
+          code: z2.ZodIssueCode.custom,
+          message: `${field} must be ISO 8601 with Z suffix (UTC)`,
+          path: [field]
+        });
+      }
+    }
+  }
+  if (msg.messageKind === "tapback" && !msg.tapback) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "tapback kind requires tapback payload",
+      path: ["tapback"]
+    });
+  }
+  if (msg.messageKind === "media" && !msg.media) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "media kind requires media payload",
+      path: ["media"]
+    });
+  }
+  if (msg.messageKind !== "media" && msg.media) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "media payload present on non-media message",
+      path: ["media"]
+    });
+  }
+  if (msg.messageKind === "media" && msg.media) {
+    if (!msg.media.id) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: "media.id is required when messageKind is media",
+        path: ["media", "id"]
+      });
+    }
+    if (!msg.media.filename) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: "media.filename is required when messageKind is media",
+        path: ["media", "filename"]
+      });
+    }
+    if (!msg.media.path) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: "media.path is required when messageKind is media",
+        path: ["media", "path"]
+      });
+    }
+  }
+});
+var ExportEnvelopeSchema = z2.object({
+  schemaVersion: z2.string(),
+  source: z2.enum(["csv", "db", "merged"]),
+  createdAt: z2.string().datetime(),
+  messages: z2.array(MessageSchema),
+  meta: z2.record(z2.any()).optional()
+}).superRefine((envelope, ctx) => {
+  if (envelope.createdAt && !envelope.createdAt.match(/Z$/)) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "createdAt must be ISO 8601 with Z suffix (UTC)",
+      path: ["createdAt"]
+    });
+  }
+});
+
+// src/ingest/ingest-csv.ts
+function ingestCSV(csvFilePath, options) {
+  const csvContent = readFileSync(csvFilePath, "utf-8");
+  const rows = parse(csvContent, { columns: true });
+  const messages = [];
+  let lineNumber = 2;
+  for (const row of rows) {
+    const rowMessages = parseCSVRow(row, lineNumber, options);
+    messages.push(...rowMessages);
+    lineNumber++;
+  }
+  return messages;
+}
+function parseCSVRow(row, lineNumber, options) {
+  const messages = [];
+  const messageDate = row["Message Date"];
+  const deliveredDate = row["Delivered Date"];
+  const readDate = row["Read Date"];
+  const editedDate = row["Edited Date"];
+  const service = row.Service;
+  const type = row.Type;
+  const senderName = row["Sender Name"];
+  const senderID = row["Sender ID"];
+  const status = row.Status;
+  const text = row.Text;
+  const subject = row.Subject;
+  const attachment = row.Attachment;
+  const attachmentType = row["Attachment type"];
+  const replyingTo = row["Replying to"];
+  const date = convertToISO8601(messageDate || "");
+  if (!date)
+    return [];
+  const isFromMe = type === "Outgoing" || type === "Sent";
+  let messageKind = "text";
+  if (type === "Notification") {
+    messageKind = "notification";
+  }
+  const baseMessage = {
+    isFromMe,
+    date
+  };
+  const handle = senderName || senderID;
+  if (handle)
+    baseMessage.handle = handle;
+  if (service)
+    baseMessage.service = service;
+  if (subject)
+    baseMessage.subject = subject;
+  if (readDate)
+    baseMessage.dateRead = convertToISO8601(readDate);
+  if (deliveredDate)
+    baseMessage.dateDelivered = convertToISO8601(deliveredDate);
+  if (editedDate) {
+    baseMessage.dateEdited = convertToISO8601(editedDate);
+    baseMessage.isEdited = true;
+  }
+  if (status === "Read")
+    baseMessage.isRead = true;
+  else if (status === "Unread")
+    baseMessage.isRead = false;
+  const baseExportMetadata = {
+    source: "csv",
+    lineNumber,
+    csvGuid: `csv:${lineNumber}:0`,
+    ...replyingTo && { replyingTo }
+  };
+  if (messageKind === "text" && text) {
+    const textMessage = {
+      ...baseMessage,
+      guid: `csv:${lineNumber}:0`,
+      messageKind: "text",
+      text,
+      exportMetadata: baseExportMetadata
+    };
+    messages.push(textMessage);
+  }
+  if (attachment && attachment.trim() !== "") {
+    const resolvedPath = resolveAttachmentPath({ filename: attachment }, {
+      ...options,
+      messageDate: date
+    });
+    if (resolvedPath) {
+      const mediaMessage = {
+        ...baseMessage,
+        guid: `csv:${lineNumber}:0:media`,
+        messageKind: "media",
+        media: {
+          id: `media:csv:${lineNumber}:0`,
+          filename: attachment,
+          path: resolvedPath,
+          mimeType: attachmentType || undefined,
+          mediaKind: inferMediaKind(attachmentType || "")
+        },
+        exportMetadata: {
+          ...baseExportMetadata,
+          attachmentIndex: 0
+        }
+      };
+      messages.push(mediaMessage);
+    }
+  }
+  if (messageKind === "notification") {
+    const notificationMessage = {
+      ...baseMessage,
+      guid: `csv:${lineNumber}:0`,
+      messageKind: "notification",
+      exportMetadata: baseExportMetadata
+    };
+    messages.push(notificationMessage);
+  }
+  if (messages.length === 0 && text) {
+    const fallbackMessage = {
+      ...baseMessage,
+      guid: `csv:${lineNumber}:0`,
+      messageKind: "text",
+      text,
+      exportMetadata: baseExportMetadata
+    };
+    messages.push(fallbackMessage);
+  }
+  return messages;
+}
+function convertToISO8601(csvDate) {
+  if (!csvDate || csvDate.trim() === "") {
+    return null;
+  }
+  try {
+    const normalized = csvDate.trim().replace(" ", "T");
+    if (!normalized.includes("-") && !normalized.includes("/")) {
+      return null;
+    }
+    let isoString = normalized;
+    if (!normalized.includes("Z") && !normalized.match(/[+-]\d{2}:/)) {
+      isoString = `${normalized}Z`;
+    }
+    const date = new Date(isoString);
+    if (Number.isNaN(date.getTime())) {
+      return null;
+    }
+    return date.toISOString();
+  } catch {
+    return null;
+  }
+}
+function resolveAttachmentPath(attachment, options) {
+  if (!attachment)
+    return null;
+  const { attachmentRoots, messageDate } = options;
+  if (attachment.copied_path?.startsWith("/")) {
+    if (existsSync(attachment.copied_path)) {
+      return attachment.copied_path;
+    }
+  }
+  if (attachment.copied_path?.startsWith("~")) {
+    const expanded = attachment.copied_path.replace("~", os.homedir());
+    if (existsSync(expanded)) {
+      return expanded;
+    }
+  }
+  if (messageDate && attachmentRoots.length > 0) {
+    const dateStr = formatDateForAttachmentSearch(messageDate);
+    const filename = attachment.filename || "unknown";
+    const senderName = attachment.senderName || "*";
+    for (const root of attachmentRoots) {
+      const pattern = `${dateStr} - ${senderName} - ${filename}`;
+      const fullPath = path.join(root, pattern);
+      if (existsSync(fullPath)) {
+        return fullPath;
+      }
+      if (senderName === "*" && existsSync(root)) {
+        try {
+          const files = readdirSync(root).filter((f) => {
+            return f.includes(dateStr) && f.endsWith(filename);
+          });
+          if (files.length > 0 && files[0]) {
+            return path.join(root, files[0]);
+          }
+        } catch {}
+      }
+    }
+  }
+  return null;
+}
+function inferMediaKind(mimeType) {
+  if (!mimeType)
+    return "unknown";
+  if (mimeType.startsWith("image/"))
+    return "image";
+  if (mimeType.startsWith("audio/"))
+    return "audio";
+  if (mimeType.startsWith("video/"))
+    return "video";
+  if (mimeType.includes("pdf"))
+    return "pdf";
+  return "unknown";
+}
+function formatDateForAttachmentSearch(isoDate) {
+  try {
+    const date = new Date(isoDate);
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const day = String(date.getUTCDate()).padStart(2, "0");
+    const hours = String(date.getUTCHours()).padStart(2, "0");
+    const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+    const seconds = String(date.getUTCSeconds()).padStart(2, "0");
+    return `${year}-${month}-${day} ${hours} ${minutes} ${seconds}`;
+  } catch {
+    return "";
+  }
+}
+function createExportEnvelope(messages) {
+  return {
+    schemaVersion: "2.0.0",
+    source: "csv",
+    createdAt: new Date().toISOString(),
+    messages
+  };
+}
+// src/utils/human.ts
+var humanEnabled = true;
+function safeConsole(kind, ...args) {
+  if (!humanEnabled)
+    return;
+  const c = globalThis.console;
+  c?.[kind]?.(...args);
+}
+function humanInfo(...args) {
+  safeConsole("info", ...args);
+}
+
+// src/utils/logger.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import fs from "node:fs";
+import path2 from "node:path";
+import pino from "pino";
+// package.json
+var package_default = {
+  author: {
+    name: "Nathan Vale",
+    url: "https://github.com/nathanvale"
+  },
+  bin: {
+    chatline: "./dist/bin/index.js"
+  },
+  bugs: {
+    url: "https://github.com/nathanvale/chatline/issues"
+  },
+  dependencies: {
+    "@google/generative-ai": "^0.21.0",
+    "@mendable/firecrawl-js": "^4.3.7",
+    "cli-progress": "^3.12.0",
+    commander: "^14.0.1",
+    "csv-parse": "^5.6.0",
+    "csv-stringify": "^6.5.2",
+    "js-yaml": "^4.1.0",
+    pino: "^10.0.0",
+    sharp: "^0.34.4",
+    zod: "^3.23.8"
+  },
+  description: "Extract, transform, and analyze iMessage conversations with AI-powered enrichment and timeline rendering.",
+  devDependencies: {
+    "@arethetypeswrong/cli": "^0.18.2",
+    "@biomejs/biome": "^2.3.7",
+    "@changesets/changelog-github": "^0.5.1",
+    "@changesets/cli": "^2.29.7",
+    "@commitlint/cli": "^20.1.0",
+    "@commitlint/config-conventional": "^20.0.0",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.0",
+    "@types/cli-progress": "^3.11.6",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^24.8.1",
+    "@vitest/coverage-v8": "^4.0.14",
+    "better-sqlite3": "^12.4.1",
+    "bun-types": "^1.3.3",
+    bunup: "^0.16.10",
+    changesets: "^1.0.2",
+    husky: "^9.1.7",
+    jsdom: "^25.0.1",
+    "lint-staged": "^15.2.10",
+    "pino-pretty": "^11.2.2",
+    publint: "^0.3.15",
+    rimraf: "^6.0.1",
+    tsx: "^4.20.6",
+    typescript: "^5.9.3",
+    vitest: "^4.0.14"
+  },
+  engines: {
+    node: ">=22.20"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  files: [
+    "dist/**",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  funding: [
+    {
+      type: "github",
+      url: "https://github.com/sponsors/nathanvale"
+    }
+  ],
+  homepage: "https://github.com/nathanvale/chatline#readme",
+  imports: {
+    "#enrich/*": "./src/enrich/*",
+    "#ingest/*": "./src/ingest/*",
+    "#normalize/*": "./src/normalize/*",
+    "#render/*": "./src/render/*",
+    "#schema/*": "./src/schema/*",
+    "#utils/*": "./src/utils/*"
+  },
+  keywords: [
+    "imessage",
+    "typescript",
+    "cli",
+    "data-pipeline",
+    "message-analysis",
+    "timeline",
+    "ai-enrichment"
+  ],
+  overrides: {
+    express: "4.22.0"
+  },
+  license: "MIT",
+  "lint-staged": {
+    "*.{ts,tsx,js,jsx,mts,cts,json}": [
+      "biome check --write"
+    ]
+  },
+  main: "./dist/index.js",
+  name: "@nathanvale/chatline",
+  publishConfig: {
+    access: "public",
+    provenance: true
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/nathanvale/chatline.git"
+  },
+  scripts: {
+    "research:actionlint": "bun scripts/firecrawl/actionlint-best-practices.ts",
+    build: "bunx bunup",
+    "check:publint": "publint",
+    "check:types": "attw --pack",
+    "check:updates": "bun pm ls || true",
+    clean: "rimraf dist 2>/dev/null || true",
+    cli: "node ./dist/bin/index.js",
+    coverage: "bun test --coverage",
+    dev: "bun src/cli.ts",
+    "docs:build": "cd website && bun run build",
+    "docs:dev": "cd website && bun run start",
+    "docs:serve": "cd website && bun run serve",
+    check: "biome check --write .",
+    format: "biome format --write .",
+    "format:check": "biome format .",
+    hygiene: "bun run check:publint && bun run check:types",
+    lint: "biome lint .",
+    "lint:fix": "biome lint --write .",
+    "lint:scripts": "shellcheck .github/scripts/*.sh",
+    "lint:workflows": "actionlint -color -verbose",
+    "pack:dry": "mkdir -p .pack && bun pm pack --destination .pack --ignore-scripts && ls -lah .pack && tar -tf .pack/*.tgz | sort | sed 's/^/ - /'",
+    "pre:enter:beta": "changeset pre enter beta",
+    "pre:enter:next": "changeset pre enter next",
+    "pre:enter:rc": "changeset pre enter rc",
+    "quality-check:ci": "biome check . && bun run typecheck",
+    "pre:exit": "changeset pre exit",
+    prepare: "husky",
+    "publish:pre": "changeset publish --provenance",
+    release: "changeset publish --provenance",
+    "release:snapshot:canary": "changeset version --snapshot canary && changeset publish --tag canary",
+    "security:audit": "npm audit",
+    start: "node ./dist/bin/index.js",
+    test: "bun test --recursive",
+    "test:ci": "TF_BUILD=true bun test --recursive",
+    "test:coverage": "bun test --coverage",
+    "test:scripts": "bash tests/smoke-test-scripts.sh",
+    "test:watch": "bun test --watch",
+    typecheck: "tsc -p tsconfig.eslint.json --noEmit",
+    "upgrade:minor": "bun update",
+    validate: "bun run lint && bun run typecheck && bun run build && TF_BUILD=true bun run test",
+    "validate:json": "bun scripts/validate-json.ts",
+    "version:gen": "changeset",
+    "version:pre": "changeset version",
+    "watch:types": "tsc -p tsconfig.eslint.json --noEmit --watch"
+  },
+  sideEffects: false,
+  type: "module",
+  types: "./dist/index.d.ts",
+  version: "0.3.0",
+  workspaces: [
+    ".",
+    "website"
+  ]
+};
+
+// src/utils/logger.ts
+var LEVEL_ORDER = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+var sequenceCounter = 0;
+var cachedVersion;
+var currentCorrelationId;
+var correlationStore = new AsyncLocalStorage;
+function loadVersion() {
+  if (cachedVersion)
+    return cachedVersion;
+  const version = package_default.version || "0.0.0";
+  cachedVersion = version;
+  return version;
+}
+var isTestEnv = process.env.VITEST === "true" || false;
+var shouldWriteFile = (process.env.LOG_TO_FILE ?? (isTestEnv ? "false" : "true")) === "true";
+var baseLevel = process.env.LOG_LEVEL || "info";
+var pinoTransport = process.env.LOG_FORMAT === "pretty" ? pino.transport({
+  target: "pino-pretty",
+  options: { colorize: true, singleLine: true }
+}) : undefined;
+var pinoStdout = pino({ level: baseLevel, base: null }, pinoTransport);
+var fileStream;
+var fileDate;
+function ensureFileStream() {
+  if (!shouldWriteFile)
+    return;
+  const nowDate = new Date().toISOString().slice(0, 10);
+  if (fileStream && fileDate === nowDate)
+    return;
+  try {
+    const logsDir = path2.resolve(process.cwd(), "logs");
+    fs.mkdirSync(logsDir, { recursive: true });
+    const filePath = path2.join(logsDir, `${nowDate}.jsonl`);
+    if (fileStream)
+      fileStream.end();
+    fileStream = fs.createWriteStream(filePath, { flags: "a" });
+    fileDate = nowDate;
+  } catch {
+    fileStream = undefined;
+    fileDate = undefined;
+  }
+}
+function log(component, level, msg, context) {
+  if (!dynamicShouldLog(level))
+    return;
+  const effectiveCorrelationId = correlationStore.getStore() ?? currentCorrelationId;
+  const entryBase = {
+    ts: new Date().toISOString(),
+    level,
+    component,
+    msg,
+    pid: process.pid,
+    ver: loadVersion(),
+    seq: ++sequenceCounter
+  };
+  const withCorr = effectiveCorrelationId ? { correlationId: effectiveCorrelationId } : {};
+  const entryNoCtx = { ...entryBase, ...withCorr };
+  const entry = context ? { ...entryNoCtx, context } : entryNoCtx;
+  const bindings = {
+    component,
+    ver: entry.ver,
+    seq: entry.seq
+  };
+  if (entry.correlationId)
+    bindings.correlationId = entry.correlationId;
+  const logger = pinoStdout.child(bindings);
+  logger[level](context ?? {}, msg);
+  if (shouldWriteFile) {
+    ensureFileStream();
+    if (fileStream)
+      fileStream.write(`${JSON.stringify(entry)}
+`);
+  }
+  if (sinks.length > 0) {
+    try {
+      for (const s of sinks)
+        s(entry);
+    } catch {}
+  }
+}
+function createLogger(component) {
+  return {
+    debug: (msg, context) => log(component, "debug", msg, context),
+    info: (msg, context) => log(component, "info", msg, context),
+    warn: (msg, context) => log(component, "warn", msg, context),
+    error: (msg, context) => log(component, "error", msg, context)
+  };
+}
+var sinks = [];
+var dynamicLevel;
+function getEffectiveLevel() {
+  return dynamicLevel || "info";
+}
+var dynamicShouldLog = (level) => {
+  const envLevel = getEffectiveLevel();
+  return LEVEL_ORDER[level] >= LEVEL_ORDER[envLevel];
+};
+
+// src/utils/incremental-state.ts
+import crypto from "node:crypto";
+import { promises as fs2 } from "node:fs";
+import path3 from "node:path";
+function detectNewMessages(currentGuids, state) {
+  const enrichedSet = new Set(state.enrichedGuids);
+  const newGuids = [];
+  for (const guid of currentGuids) {
+    if (!enrichedSet.has(guid)) {
+      newGuids.push(guid);
+    }
+  }
+  return newGuids;
+}
+async function loadIncrementalState(filePath) {
+  try {
+    const content = await fs2.readFile(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (parsed.version !== "1.0") {
+      const logger = createLogger("utils:incremental-state");
+      logger.warn("Unknown state version. Ignoring.", {
+        version: parsed.version
+      });
+      return null;
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("ENOENT")) {
+      return null;
+    }
+    return null;
+  }
+}
+
+// src/utils/delta-detection.ts
+async function loadPreviousState(stateFilePath) {
+  return loadIncrementalState(stateFilePath);
+}
+function extractGuidsFromMessages(messages) {
+  const guids = new Set;
+  for (const msg of messages) {
+    guids.add(msg.guid);
+  }
+  return guids;
+}
+function computeDelta(currentGuids, previousState) {
+  if (!previousState) {
+    return Array.from(currentGuids);
+  }
+  return detectNewMessages(currentGuids, previousState);
+}
+function logDeltaSummary(result) {
+  const logger = createLogger("utils:delta-detection");
+  const newCount = result.newCount;
+  const totalCount = result.totalMessages;
+  const previousCount = result.previousEnrichedCount;
+  if (result.isFirstRun) {
+    logger.info("First enrichment run", { totalMessages: totalCount });
+    humanInfo(`First enrichment run: ${totalCount} messages`);
+  } else {
+    const percentNew = totalCount > 0 ? newCount / totalCount * 100 : 0;
+    logger.info("Delta detected", {
+      newMessages: newCount,
+      percentNew,
+      totalMessages: totalCount,
+      previouslyEnriched: previousCount
+    });
+    humanInfo(`Delta detected: ${newCount} new messages (${percentNew.toFixed(1)}%) of ${totalCount} total messages`);
+    humanInfo(`Previously enriched: ${previousCount}`);
+  }
+}
+async function detectDelta(messages, stateFilePath) {
+  const previousState = await loadPreviousState(stateFilePath);
+  const isFirstRun = previousState === null;
+  const currentGuids = extractGuidsFromMessages(messages);
+  const newGuids = computeDelta(currentGuids, previousState);
+  const result = {
+    newGuids,
+    totalMessages: messages.length,
+    previousEnrichedCount: previousState?.enrichedGuids.length ?? 0,
+    newCount: newGuids.length,
+    isFirstRun,
+    state: previousState ?? {
+      version: "1.0",
+      lastEnrichedAt: new Date().toISOString(),
+      totalMessages: messages.length,
+      enrichedGuids: [],
+      pipelineConfig: {
+        configHash: ""
+      },
+      enrichmentStats: null
+    }
+  };
+  logDeltaSummary(result);
+  return result;
+}
+function getDeltaStats(result) {
+  const total = result.totalMessages;
+  const newCount = result.newCount;
+  const previousCount = result.previousEnrichedCount;
+  return {
+    total,
+    new: newCount,
+    previous: previousCount,
+    percentNew: total > 0 ? newCount / total * 100 : 0,
+    percentPrevious: total > 0 ? previousCount / total * 100 : 0
+  };
+}
+// src/utils/enrichment-merge.ts
+import { promises as fs3 } from "node:fs";
+function mergeEnrichments(existingMessages, newMessages, options = {}) {
+  const existingByGuid = new Map;
+  for (const msg of existingMessages) {
+    existingByGuid.set(msg.guid, msg);
+  }
+  let mergedCount = 0;
+  let addedCount = 0;
+  let preservedCount = 0;
+  const processedGuids = new Set;
+  const resultMessages = [];
+  for (const newMsg of newMessages) {
+    const existing = existingByGuid.get(newMsg.guid);
+    if (existing) {
+      if (!processedGuids.has(newMsg.guid)) {
+        const merged = mergeMessageEnrichments(existing, newMsg, options);
+        resultMessages.push(merged);
+        mergedCount++;
+        if (merged.messageKind === "media" && merged.media?.enrichment && merged.media.enrichment.length > 0) {
+          preservedCount++;
+        }
+        processedGuids.add(newMsg.guid);
+      }
+    } else {
+      if (!processedGuids.has(newMsg.guid)) {
+        resultMessages.push(newMsg);
+        addedCount++;
+        processedGuids.add(newMsg.guid);
+      }
+    }
+  }
+  const totalMessages = resultMessages.length;
+  return {
+    messages: resultMessages,
+    statistics: {
+      mergedCount,
+      addedCount,
+      preservedCount,
+      totalMessages,
+      mergedPercentage: totalMessages > 0 ? mergedCount / totalMessages * 100 : 0,
+      addedPercentage: totalMessages > 0 ? addedCount / totalMessages * 100 : 0
+    },
+    mergedCount,
+    addedCount,
+    preservedCount
+  };
+}
+function mergeMessageEnrichments(existing, newMsg, options) {
+  if (existing.messageKind !== "media" || !existing.media) {
+    return existing;
+  }
+  if (!newMsg.media?.enrichment || newMsg.media.enrichment.length === 0) {
+    return existing;
+  }
+  if (options.forceRefresh) {
+    return {
+      ...existing,
+      media: {
+        ...existing.media,
+        enrichment: newMsg.media.enrichment
+      }
+    };
+  }
+  const existingEnrichment = existing.media.enrichment ?? [];
+  const newEnrichment = newMsg.media.enrichment ?? [];
+  const existingKinds = new Set(existingEnrichment.map((e) => e.kind));
+  const mergedEnrichment = [
+    ...existingEnrichment,
+    ...newEnrichment.filter((e) => !existingKinds.has(e.kind))
+  ];
+  return {
+    ...existing,
+    media: {
+      ...existing.media,
+      enrichment: mergedEnrichment
+    }
+  };
+}
+export {
+  validateGeneratedConfig,
+  validateConfigSafe,
+  validateConfig,
+  substituteEnvVars,
+  mergeEnrichments,
+  mergeConfig,
+  logDeltaSummary,
+  loadConfigFile,
+  loadConfig,
+  isRetryableStatus,
+  isConfigCached,
+  is5xx,
+  ingestCSV,
+  getDeltaStats,
+  getDefaultConfigPath,
+  generateConfigContent,
+  extractGuidsFromMessages,
+  discoverConfigFile,
+  detectDelta,
+  detectConfigFormat,
+  dedupAndMerge,
+  createRateLimiter,
+  createExportEnvelope,
+  clearConfigCache,
+  TapbackInfoSchema,
+  ReplyInfoSchema,
+  RateLimiter,
+  MessageCoreSchema,
+  MediaProvenanceSchema,
+  MediaMetaSchema,
+  MediaEnrichmentSchema,
+  DEFAULT_CONFIG,
+  CONFIG_FILE_PATTERNS
+};