@msbayindir/context-rag 1.0.0-beta.1

package/dist/index.cjs

@@ -0,0 +1,2877 @@
+'use strict';
+
+var zod = require('zod');
+var crypto = require('crypto');
+var generativeAi = require('@google/generative-ai');
+var server = require('@google/generative-ai/server');
+var fs = require('fs/promises');
+var path = require('path');
+var pdf = require('pdf-parse');
+var pLimit = require('p-limit');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var pdf__default = /*#__PURE__*/_interopDefault(pdf);
+var pLimit__default = /*#__PURE__*/_interopDefault(pLimit);
+
+// src/types/config.types.ts
+var DEFAULT_BATCH_CONFIG = {
+  pagesPerBatch: 15,
+  maxConcurrency: 3,
+  maxRetries: 3,
+  retryDelayMs: 1e3,
+  backoffMultiplier: 2
+};
+var DEFAULT_CHUNK_CONFIG = {
+  maxTokens: 500,
+  overlapTokens: 50
+};
+var DEFAULT_RATE_LIMIT_CONFIG = {
+  requestsPerMinute: 60,
+  adaptive: true
+};
+var DEFAULT_GENERATION_CONFIG = {
+  temperature: 0.3,
+  maxOutputTokens: 8192
+};
+var DEFAULT_LOG_CONFIG = {
+  level: "info",
+  structured: true
+};
+var configSchema = zod.z.object({
+  geminiApiKey: zod.z.string().min(1, "Gemini API key is required"),
+  model: zod.z.enum([
+    "gemini-1.5-pro",
+    "gemini-1.5-flash",
+    "gemini-2.0-flash-exp",
+    "gemini-pro",
+    "gemini-2.5-pro",
+    "gemini-3-pro-preview",
+    "gemini-3-flash-preview"
+  ]).optional(),
+  embeddingModel: zod.z.string().optional(),
+  batchConfig: zod.z.object({
+    pagesPerBatch: zod.z.number().min(1).max(50).optional(),
+    maxConcurrency: zod.z.number().min(1).max(10).optional(),
+    maxRetries: zod.z.number().min(0).max(10).optional(),
+    retryDelayMs: zod.z.number().min(100).max(6e4).optional(),
+    backoffMultiplier: zod.z.number().min(1).max(5).optional()
+  }).optional(),
+  chunkConfig: zod.z.object({
+    maxTokens: zod.z.number().min(100).max(2e3).optional(),
+    overlapTokens: zod.z.number().min(0).max(500).optional()
+  }).optional(),
+  rateLimitConfig: zod.z.object({
+    requestsPerMinute: zod.z.number().min(1).max(1e3).optional(),
+    adaptive: zod.z.boolean().optional()
+  }).optional(),
+  logging: zod.z.object({
+    level: zod.z.enum(["debug", "info", "warn", "error"]).optional(),
+    structured: zod.z.boolean().optional()
+  }).optional()
+});
+
+// src/errors/index.ts
+var ContextRAGError = class extends Error {
+  code;
+  details;
+  constructor(message, code, details) {
+    super(message);
+    this.name = "ContextRAGError";
+    this.code = code;
+    this.details = details;
+    Error.captureStackTrace(this, this.constructor);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      details: this.details
+    };
+  }
+};
+var ConfigurationError = class extends ContextRAGError {
+  constructor(message, details) {
+    super(message, "CONFIGURATION_ERROR", details);
+    this.name = "ConfigurationError";
+  }
+};
+var IngestionError = class extends ContextRAGError {
+  batchIndex;
+  retryable;
+  constructor(message, options = {}) {
+    super(message, "INGESTION_ERROR", options.details);
+    this.name = "IngestionError";
+    this.batchIndex = options.batchIndex;
+    this.retryable = options.retryable ?? false;
+  }
+};
+var SearchError = class extends ContextRAGError {
+  constructor(message, details) {
+    super(message, "SEARCH_ERROR", details);
+    this.name = "SearchError";
+  }
+};
+var DiscoveryError = class extends ContextRAGError {
+  constructor(message, details) {
+    super(message, "DISCOVERY_ERROR", details);
+    this.name = "DiscoveryError";
+  }
+};
+var DatabaseError = class extends ContextRAGError {
+  constructor(message, details) {
+    super(message, "DATABASE_ERROR", details);
+    this.name = "DatabaseError";
+  }
+};
+var RateLimitError = class extends ContextRAGError {
+  retryAfterMs;
+  constructor(message, retryAfterMs) {
+    super(message, "RATE_LIMIT_ERROR", { retryAfterMs });
+    this.name = "RateLimitError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+var NotFoundError = class extends ContextRAGError {
+  resourceType;
+  resourceId;
+  constructor(resourceType, resourceId) {
+    super(`${resourceType} not found: ${resourceId}`, "NOT_FOUND", {
+      resourceType,
+      resourceId
+    });
+    this.name = "NotFoundError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+  }
+};
+
+// src/utils/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function createLogger(config) {
+  const currentLevel = LOG_LEVELS[config.level];
+  const shouldLog = (level) => {
+    return LOG_LEVELS[level] >= currentLevel;
+  };
+  const formatMessage = (level, message, meta) => {
+    if (config.structured) {
+      return JSON.stringify({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level,
+        message,
+        ...meta
+      });
+    }
+    const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
+    return `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level.toUpperCase()}] ${message}${metaStr}`;
+  };
+  const log = (level, message, meta) => {
+    if (!shouldLog(level)) return;
+    if (config.customLogger) {
+      config.customLogger(level, message, meta);
+      return;
+    }
+    const formattedMessage = formatMessage(level, message, meta);
+    switch (level) {
+      case "debug":
+      case "info":
+        console.log(formattedMessage);
+        break;
+      case "warn":
+        console.warn(formattedMessage);
+        break;
+      case "error":
+        console.error(formattedMessage);
+        break;
+    }
+  };
+  return {
+    debug: (message, meta) => log("debug", message, meta),
+    info: (message, meta) => log("info", message, meta),
+    warn: (message, meta) => log("warn", message, meta),
+    error: (message, meta) => log("error", message, meta)
+  };
+}
+function generateCorrelationId() {
+  return `crag_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function hashBuffer(buffer) {
+  return crypto.createHash("sha256").update(buffer).digest("hex");
+}
+
+// src/utils/retry.ts
+function getRetryOptions(batchConfig) {
+  return {
+    maxRetries: batchConfig.maxRetries,
+    initialDelayMs: batchConfig.retryDelayMs,
+    maxDelayMs: 3e4,
+    backoffMultiplier: batchConfig.backoffMultiplier,
+    retryableErrors: ["429", "503", "TIMEOUT", "ECONNRESET", "ETIMEDOUT"]
+  };
+}
+function isRetryableError(error, retryableErrors = []) {
+  const errorString = error.message + (error.name || "");
+  if (error instanceof RateLimitError) {
+    return true;
+  }
+  return retryableErrors.some(
+    (pattern) => errorString.includes(pattern) || error.name.includes(pattern)
+  );
+}
+function calculateBackoffDelay(attempt, initialDelayMs, backoffMultiplier, maxDelayMs) {
+  const delay = initialDelayMs * Math.pow(backoffMultiplier, attempt - 1);
+  const jitter = delay * 0.1 * (Math.random() * 2 - 1);
+  return Math.min(delay + jitter, maxDelayMs);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, options) {
+  let lastError;
+  for (let attempt = 1; attempt <= options.maxRetries + 1; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt > options.maxRetries) {
+        break;
+      }
+      if (!isRetryableError(lastError, options.retryableErrors)) {
+        throw lastError;
+      }
+      let delayMs = calculateBackoffDelay(
+        attempt,
+        options.initialDelayMs,
+        options.backoffMultiplier,
+        options.maxDelayMs
+      );
+      if (lastError instanceof RateLimitError && lastError.retryAfterMs) {
+        delayMs = Math.max(delayMs, lastError.retryAfterMs);
+      }
+      options.onRetry?.(attempt, lastError, delayMs);
+      await sleep(delayMs);
+    }
+  }
+  throw lastError;
+}
+
+// src/utils/rate-limiter.ts
+var RateLimiter = class {
+  config;
+  state;
+  minRpm;
+  maxRpm;
+  intervalMs = 6e4;
+  // 1 minute
+  constructor(config) {
+    this.config = config;
+    this.minRpm = Math.floor(config.requestsPerMinute * 0.2);
+    this.maxRpm = Math.floor(config.requestsPerMinute * 1.5);
+    this.state = {
+      tokens: config.requestsPerMinute,
+      lastRefill: Date.now(),
+      currentRpm: config.requestsPerMinute,
+      consecutiveSuccesses: 0,
+      consecutiveFailures: 0
+    };
+  }
+  /**
+   * Wait until a token is available and consume it
+   */
+  async acquire() {
+    this.refillTokens();
+    while (this.state.tokens < 1) {
+      const waitTime = this.calculateWaitTime();
+      await sleep(waitTime);
+      this.refillTokens();
+    }
+    this.state.tokens -= 1;
+  }
+  /**
+   * Report a successful request (for adaptive rate limiting)
+   */
+  reportSuccess() {
+    if (!this.config.adaptive) return;
+    this.state.consecutiveSuccesses += 1;
+    this.state.consecutiveFailures = 0;
+    if (this.state.consecutiveSuccesses >= 10) {
+      this.adjustRate(1.1);
+      this.state.consecutiveSuccesses = 0;
+    }
+  }
+  /**
+   * Report a rate limit error (for adaptive rate limiting)
+   */
+  reportRateLimitError() {
+    if (!this.config.adaptive) return;
+    this.state.consecutiveFailures += 1;
+    this.state.consecutiveSuccesses = 0;
+    this.adjustRate(0.7);
+  }
+  /**
+   * Get current rate limit status
+   */
+  getStatus() {
+    this.refillTokens();
+    return {
+      currentRpm: this.state.currentRpm,
+      availableTokens: Math.floor(this.state.tokens)
+    };
+  }
+  refillTokens() {
+    const now = Date.now();
+    const elapsed = now - this.state.lastRefill;
+    const tokensToAdd = elapsed / this.intervalMs * this.state.currentRpm;
+    this.state.tokens = Math.min(
+      this.state.tokens + tokensToAdd,
+      this.state.currentRpm
+    );
+    this.state.lastRefill = now;
+  }
+  calculateWaitTime() {
+    const tokensNeeded = 1 - this.state.tokens;
+    return Math.ceil(tokensNeeded / this.state.currentRpm * this.intervalMs);
+  }
+  adjustRate(multiplier) {
+    const newRpm = Math.floor(this.state.currentRpm * multiplier);
+    this.state.currentRpm = Math.max(this.minRpm, Math.min(newRpm, this.maxRpm));
+  }
+};
+
+// src/config/templates.ts
+var DISCOVERY_TEMPLATE = `You are a document analysis AI. Analyze the provided document and determine the optimal processing strategy.
+
+Analyze the document and return ONLY a JSON response with the following structure:
+
+{
+  "documentType": "Medical|Legal|Financial|Technical|Academic|General",
+  "documentTypeName": "Human readable name for this document type",
+  "language": "tr|en|de|fr|...",
+  "complexity": "low|medium|high",
+  
+  "detectedElements": [
+    { "type": "table", "count": 5, "description": "Brief description of tables" },
+    { "type": "list", "count": 10, "description": "Brief description of lists" },
+    { "type": "code", "count": 0, "description": "" },
+    { "type": "image", "count": 3, "description": "Brief description of images" }
+  ],
+  
+  "specialInstructions": [
+    "Specific instruction 1 for this document type",
+    "Specific instruction 2 for this document type",
+    "Specific instruction 3 for this document type"
+  ],
+  
+  "exampleFormats": {
+    "example1": "How a specific format should look",
+    "example2": "Another format example"
+  },
+  
+  "chunkStrategy": {
+    "maxTokens": 800,
+    "overlapTokens": 100,
+    "splitBy": "section|page|paragraph|semantic",
+    "preserveTables": true,
+    "preserveLists": true
+  },
+  
+  "confidence": 0.85,
+  "reasoning": "Brief explanation of why this strategy was chosen"
+}
+
+IMPORTANT RULES:
+1. DO NOT generate a full extraction prompt
+2. Only provide structured analysis and specific instructions
+3. Instructions should be actionable and specific to this document type
+4. Example formats help maintain consistency in extraction
+
+{{DOCUMENT_TYPE_HINT}}
+`;
+var BASE_EXTRACTION_TEMPLATE = `You are a document processing AI. Extract content following the EXACT format below.
+
+## OUTPUT FORMAT (MANDATORY - DO NOT MODIFY)
+
+Use this structure for EVERY content section:
+
+<!-- SECTION type="[TYPE]" page="[PAGE]" confidence="[0.0-1.0]" -->
+[Content here in Markdown format]
+<!-- /SECTION -->
+
+### Valid Types:
+- TEXT: Regular paragraphs and prose
+- TABLE: Data tables in Markdown format
+- LIST: Bullet (-) or numbered (1. 2. 3.) lists
+- HEADING: Section headers with # ## ### levels
+- CODE: Code blocks with language specification
+- QUOTE: Quoted text or citations
+- IMAGE_REF: Description of images, charts, figures
+- QUESTION: Multiple choice questions with options (A, B, C, D, E)
+
+### Format Rules:
+1. **Tables**: Use Markdown table format
+   | Column1 | Column2 | Column3 |
+   |---------|---------|---------|
+   | data    | data    | data    |
+
+2. **Lists**: Use consistent format
+   - Bullet item
+   - Another bullet
+   
+   OR
+   
+   1. Numbered item
+   2. Another numbered
+
+3. **Headings**: Maximum 3 levels, use hierarchy
+   # Main Section
+   ## Subsection
+   ### Sub-subsection
+
+4. **Code**: Specify language
+   \`\`\`python
+   code here
+   \`\`\`
+
+5. **Images**: Describe visual content
+   [IMAGE: Description of what the image shows]
+
+6. **Questions**: Multiple choice questions with options
+   **Question 1:** Question text here?
+   A) Option A text
+   B) Option B text
+   C) Option C text
+   D) Option D text
+   E) Option E text (if exists)
+   **Answer:** [Letter] (if answer is provided in document)
+
+## DOCUMENT-SPECIFIC INSTRUCTIONS
+{{DOCUMENT_INSTRUCTIONS}}
+
+## CRITICAL EXTRACTION RULES (DO NOT VIOLATE)
+\u26A0\uFE0F These rules are MANDATORY for legal, medical, and financial document accuracy:
+
+1. **NO SUMMARIZATION**: Extract content EXACTLY as written. Do not summarize, paraphrase, or condense.
+2. **NO INTERPRETATION**: Do not interpret, explain, or add commentary to the content.
+3. **PRESERVE ORIGINAL WORDING**: Keep exact terminology, especially for:
+   - Legal terms, clauses, and article references
+   - Medical terminology, diagnoses, and prescriptions
+   - Financial figures, percentages, and calculations
+   - Technical specifications and measurements
+4. **VERBATIM EXTRACTION**: Copy text word-for-word from the document.
+5. **NO OMISSIONS**: Include all content, even if it seems redundant or repetitive.
+6. **UNCLEAR CONTENT**: If text is unclear or illegible, extract as-is and mark: [UNCLEAR: partial text visible]
+7. **FOREIGN TERMS**: Keep foreign language terms, Latin phrases, and abbreviations exactly as written.
+
+## PROCESSING RULES
+- Extract ALL content completely, do not summarize or skip
+- Preserve original document structure and hierarchy
+- Include page references for each section
+- Maintain technical accuracy and terminology
+- Use appropriate confidence scores based on extraction quality
+- If content spans multiple pages, use the starting page number
+
+## PAGE RANGE
+{{PAGE_RANGE}}
+`;
+var DEFAULT_DOCUMENT_INSTRUCTIONS = `
+- Extract all text content preserving structure
+- Convert tables to Markdown table format
+- Convert lists to Markdown list format
+- Preserve headings with appropriate # levels
+- Note any images with descriptive text
+- Maintain the logical flow of content
+`;
+function buildExtractionPrompt(documentInstructions, exampleFormats, pageStart, pageEnd) {
+  let instructionsBlock = documentInstructions.map((instruction) => `- ${instruction}`).join("\n");
+  if (exampleFormats && Object.keys(exampleFormats).length > 0) {
+    instructionsBlock += "\n\n### Example Formats:\n";
+    for (const [key, value] of Object.entries(exampleFormats)) {
+      instructionsBlock += `- **${key}**: \`${value}\`
+`;
+    }
+  }
+  let pageRange = "";
+  if (pageStart !== void 0 && pageEnd !== void 0) {
+    if (pageStart === pageEnd) {
+      pageRange = `Process page ${pageStart} of this document.`;
+    } else {
+      pageRange = `Process pages ${pageStart}-${pageEnd} of this document.`;
+    }
+  }
+  return BASE_EXTRACTION_TEMPLATE.replace("{{DOCUMENT_INSTRUCTIONS}}", instructionsBlock || DEFAULT_DOCUMENT_INSTRUCTIONS).replace("{{PAGE_RANGE}}", pageRange);
+}
+function buildDiscoveryPrompt(documentTypeHint) {
+  let hint = "";
+  if (documentTypeHint) {
+    hint = `
+Hint: The user expects this to be a "${documentTypeHint}" document. Consider this when analyzing.`;
+  }
+  return DISCOVERY_TEMPLATE.replace("{{DOCUMENT_TYPE_HINT}}", hint);
+}
+var SECTION_PATTERN = /<!-- SECTION type="(\w+)" page="(\d+)" confidence="([\d.]+)" -->\n?([\s\S]*?)\n?<!-- \/SECTION -->/g;
+
+// src/types/enums.ts
+var ChunkTypeEnum = {
+  TEXT: "TEXT",
+  TABLE: "TABLE",
+  LIST: "LIST",
+  CODE: "CODE",
+  HEADING: "HEADING",
+  IMAGE_REF: "IMAGE_REF",
+  QUOTE: "QUOTE",
+  QUESTION: "QUESTION",
+  MIXED: "MIXED"
+};
+var BatchStatusEnum = {
+  PENDING: "PENDING",
+  PROCESSING: "PROCESSING",
+  RETRYING: "RETRYING",
+  COMPLETED: "COMPLETED",
+  FAILED: "FAILED"
+};
+var DocumentStatusEnum = {
+  PENDING: "PENDING",
+  DISCOVERING: "DISCOVERING",
+  AWAITING_APPROVAL: "AWAITING_APPROVAL",
+  PROCESSING: "PROCESSING",
+  COMPLETED: "COMPLETED",
+  FAILED: "FAILED",
+  PARTIAL: "PARTIAL"
+};
+var SearchModeEnum = {
+  SEMANTIC: "semantic",
+  KEYWORD: "keyword",
+  HYBRID: "hybrid"
+};
+
+// src/utils/chunk-parser.ts
+function parseSections(aiOutput) {
+  const sections = [];
+  const regex = new RegExp(SECTION_PATTERN.source, "g");
+  let match;
+  let index = 0;
+  while ((match = regex.exec(aiOutput)) !== null) {
+    const typeStr = (match[1] ?? "TEXT").toUpperCase();
+    const page = parseInt(match[2] ?? "1", 10);
+    const confidence = parseFloat(match[3] ?? "0.5");
+    const content = (match[4] ?? "").trim();
+    const type = mapToChunkType(typeStr);
+    sections.push({
+      type,
+      page,
+      confidence: isNaN(confidence) ? 0.5 : Math.min(1, Math.max(0, confidence)),
+      content,
+      index: index++
+    });
+  }
+  return sections;
+}
+function mapToChunkType(typeStr) {
+  const typeMap = {
+    "TEXT": ChunkTypeEnum.TEXT,
+    "TABLE": ChunkTypeEnum.TABLE,
+    "LIST": ChunkTypeEnum.LIST,
+    "CODE": ChunkTypeEnum.CODE,
+    "HEADING": ChunkTypeEnum.HEADING,
+    "QUOTE": ChunkTypeEnum.QUOTE,
+    "IMAGE_REF": ChunkTypeEnum.IMAGE_REF,
+    "QUESTION": ChunkTypeEnum.QUESTION,
+    "MIXED": ChunkTypeEnum.MIXED
+  };
+  return typeMap[typeStr] ?? ChunkTypeEnum.TEXT;
+}
+function hasValidSections(aiOutput) {
+  const regex = new RegExp(SECTION_PATTERN.source);
+  return regex.test(aiOutput);
+}
+function parseFallbackContent(content, pageStart, _pageEnd) {
+  const sections = [];
+  const parts = content.split(/\n(?=#{1,6}\s)|(?:\n\n)/);
+  let index = 0;
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed || trimmed.length < 10) continue;
+    sections.push({
+      type: detectContentType(trimmed),
+      page: pageStart,
+      confidence: 0.6,
+      // Lower confidence for fallback
+      content: trimmed,
+      index: index++
+    });
+  }
+  return sections;
+}
+function detectContentType(content) {
+  if (content.includes("|") && content.includes("---")) {
+    return ChunkTypeEnum.TABLE;
+  }
+  if (/^[-*]\s/m.test(content) || /^\d+\.\s/m.test(content)) {
+    return ChunkTypeEnum.LIST;
+  }
+  if (content.includes("```")) {
+    return ChunkTypeEnum.CODE;
+  }
+  if (/^#{1,6}\s/.test(content)) {
+    return ChunkTypeEnum.HEADING;
+  }
+  if (content.startsWith(">")) {
+    return ChunkTypeEnum.QUOTE;
+  }
+  if (content.includes("[IMAGE:")) {
+    return ChunkTypeEnum.IMAGE_REF;
+  }
+  if (/[A-E][).]\s/m.test(content) && /[B-E][).]\s/m.test(content)) {
+    return ChunkTypeEnum.QUESTION;
+  }
+  return ChunkTypeEnum.TEXT;
+}
+function cleanForSearch(content) {
+  return content.replace(/#{1,6}\s/g, "").replace(/\*\*/g, "").replace(/\*/g, "").replace(/`/g, "").replace(/\|/g, " ").replace(/---+/g, "").replace(/\[IMAGE:[^\]]*\]/g, "").replace(/<!--.*?-->/gs, "").replace(/\s+/g, " ").trim();
+}
+
+// src/types/prompt.types.ts
+var DEFAULT_CHUNK_STRATEGY = {
+  maxTokens: 500,
+  overlapTokens: 50,
+  splitBy: "semantic",
+  preserveTables: true,
+  preserveLists: true,
+  extractHeadings: true
+};
+
+// src/database/repositories/prompt-config.repository.ts
+var PromptConfigRepository = class {
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  /**
+   * Create a new prompt configuration
+   */
+  async create(input) {
+    try {
+      const latestVersion = await this.prisma.contextRagPromptConfig.findFirst({
+        where: { documentType: input.documentType },
+        orderBy: { version: "desc" },
+        select: { version: true }
+      });
+      const version = (latestVersion?.version ?? 0) + 1;
+      if (input.setAsDefault) {
+        await this.prisma.contextRagPromptConfig.updateMany({
+          where: { documentType: input.documentType, isDefault: true },
+          data: { isDefault: false }
+        });
+      }
+      const chunkStrategy = {
+        ...DEFAULT_CHUNK_STRATEGY,
+        ...input.chunkStrategy
+      };
+      const created = await this.prisma.contextRagPromptConfig.create({
+        data: {
+          documentType: input.documentType,
+          name: input.name,
+          systemPrompt: input.systemPrompt,
+          chunkStrategy,
+          version,
+          isActive: true,
+          isDefault: input.setAsDefault ?? false,
+          createdBy: "manual",
+          changeLog: input.changeLog
+        }
+      });
+      return this.mapToPromptConfig(created);
+    } catch (error) {
+      throw new DatabaseError("Failed to create prompt config", {
+        error: error.message,
+        documentType: input.documentType
+      });
+    }
+  }
+  /**
+   * Get a prompt configuration by ID
+   */
+  async getById(id) {
+    const config = await this.prisma.contextRagPromptConfig.findUnique({
+      where: { id }
+    });
+    if (!config) {
+      throw new NotFoundError("PromptConfig", id);
+    }
+    return this.mapToPromptConfig(config);
+  }
+  /**
+   * Get prompt configurations with optional filters
+   */
+  async getMany(filters) {
+    const where = {};
+    if (filters?.documentType) {
+      where["documentType"] = filters.documentType;
+    }
+    if (filters?.activeOnly) {
+      where["isActive"] = true;
+    }
+    if (filters?.defaultOnly) {
+      where["isDefault"] = true;
+    }
+    if (filters?.createdBy) {
+      where["createdBy"] = filters.createdBy;
+    }
+    const configs = await this.prisma.contextRagPromptConfig.findMany({
+      where,
+      orderBy: [{ documentType: "asc" }, { version: "desc" }]
+    });
+    return configs.map((c) => this.mapToPromptConfig(c));
+  }
+  /**
+   * Get the active default config for a document type
+   */
+  async getDefault(documentType) {
+    const config = await this.prisma.contextRagPromptConfig.findFirst({
+      where: {
+        documentType,
+        isActive: true,
+        isDefault: true
+      }
+    });
+    return config ? this.mapToPromptConfig(config) : null;
+  }
+  /**
+   * Get the latest active config for a document type
+   */
+  async getLatest(documentType) {
+    const config = await this.prisma.contextRagPromptConfig.findFirst({
+      where: {
+        documentType,
+        isActive: true
+      },
+      orderBy: { version: "desc" }
+    });
+    return config ? this.mapToPromptConfig(config) : null;
+  }
+  /**
+   * Activate a specific config version
+   */
+  async activate(id) {
+    const config = await this.prisma.contextRagPromptConfig.findUnique({
+      where: { id }
+    });
+    if (!config) {
+      throw new NotFoundError("PromptConfig", id);
+    }
+    await this.prisma.contextRagPromptConfig.updateMany({
+      where: {
+        documentType: config.documentType,
+        id: { not: id }
+      },
+      data: { isActive: false, isDefault: false }
+    });
+    await this.prisma.contextRagPromptConfig.update({
+      where: { id },
+      data: { isActive: true, isDefault: true }
+    });
+  }
+  /**
+   * Deactivate a config
+   */
+  async deactivate(id) {
+    await this.prisma.contextRagPromptConfig.update({
+      where: { id },
+      data: { isActive: false, isDefault: false }
+    });
+  }
+  /**
+   * Delete a config (only if no chunks reference it)
+   */
+  async delete(id) {
+    const chunkCount = await this.prisma.contextRagChunk.count({
+      where: { promptConfigId: id }
+    });
+    if (chunkCount > 0) {
+      throw new DatabaseError("Cannot delete prompt config with existing chunks", {
+        id,
+        chunkCount
+      });
+    }
+    await this.prisma.contextRagPromptConfig.delete({
+      where: { id }
+    });
+  }
+  /**
+   * Map database record to PromptConfig type
+   */
+  mapToPromptConfig(record) {
+    return {
+      id: record["id"],
+      documentType: record["documentType"],
+      name: record["name"],
+      systemPrompt: record["systemPrompt"],
+      chunkStrategy: record["chunkStrategy"],
+      version: record["version"],
+      isActive: record["isActive"],
+      isDefault: record["isDefault"],
+      createdBy: record["createdBy"],
+      changeLog: record["changeLog"],
+      createdAt: record["createdAt"],
+      updatedAt: record["updatedAt"]
+    };
+  }
+};
+
+// src/database/repositories/document.repository.ts
+var DocumentRepository = class {
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  /**
+   * Create a new document record
+   */
+  async create(input) {
+    try {
+      const doc = await this.prisma.contextRagDocument.create({
+        data: {
+          filename: input.filename,
+          fileHash: input.fileHash,
+          fileSize: input.fileSize,
+          pageCount: input.pageCount,
+          documentType: input.documentType,
+          promptConfigId: input.promptConfigId,
+          status: DocumentStatusEnum.PENDING,
+          totalBatches: input.totalBatches,
+          experimentId: input.experimentId,
+          modelName: input.modelName,
+          modelConfig: input.modelConfig
+        }
+      });
+      return doc.id;
+    } catch (error) {
+      if (error.code === "P2002") {
+        throw new DatabaseError("Document with this hash and experimentId already exists", {
+          fileHash: input.fileHash,
+          experimentId: input.experimentId
+        });
+      }
+      throw new DatabaseError("Failed to create document", {
+        error: error.message
+      });
+    }
+  }
+  /**
+   * Get document by ID
+   */
+  async getById(id) {
+    const doc = await this.prisma.contextRagDocument.findUnique({
+      where: { id }
+    });
+    if (!doc) {
+      throw new NotFoundError("Document", id);
+    }
+    return this.mapToDocumentStatus(doc);
+  }
+  /**
+   * Get document by file hash (legacy - returns first match)
+   */
+  async getByHash(fileHash) {
+    const doc = await this.prisma.contextRagDocument.findFirst({
+      where: { fileHash }
+    });
+    return doc ? this.mapToDocumentStatus(doc) : null;
+  }
+  /**
+   * Get document by file hash and experiment ID
+   */
+  async getByHashAndExperiment(fileHash, experimentId) {
+    const doc = await this.prisma.contextRagDocument.findFirst({
+      where: {
+        fileHash,
+        experimentId: experimentId ?? null
+      }
+    });
+    return doc ? this.mapToDocumentStatus(doc) : null;
+  }
+  /**
+   * Update document
+   */
+  async update(id, input) {
+    await this.prisma.contextRagDocument.update({
+      where: { id },
+      data: input
+    });
+  }
+  /**
+   * Increment completed batches count
+   */
+  async incrementCompleted(id) {
+    await this.prisma.contextRagDocument.update({
+      where: { id },
+      data: {
+        completedBatches: { increment: 1 }
+      }
+    });
+  }
+  /**
+   * Increment failed batches count
+   */
+  async incrementFailed(id) {
+    await this.prisma.contextRagDocument.update({
+      where: { id },
+      data: {
+        failedBatches: { increment: 1 }
+      }
+    });
+  }
+  /**
+   * Mark document as completed
+   */
+  async markCompleted(id, tokenUsage, processingMs) {
+    const doc = await this.prisma.contextRagDocument.findUnique({
+      where: { id },
+      select: { failedBatches: true }
+    });
+    const status = doc?.failedBatches > 0 ? DocumentStatusEnum.PARTIAL : DocumentStatusEnum.COMPLETED;
+    await this.prisma.contextRagDocument.update({
+      where: { id },
+      data: {
+        status,
+        tokenUsage,
+        processingMs,
+        completedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  /**
+   * Mark document as failed
+   */
+  async markFailed(id, errorMessage) {
+    await this.prisma.contextRagDocument.update({
+      where: { id },
+      data: {
+        status: DocumentStatusEnum.FAILED,
+        errorMessage,
+        completedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  /**
+   * Delete document and all related data
+   */
+  async delete(id) {
+    await this.prisma.contextRagDocument.delete({
+      where: { id }
+    });
+  }
+  /**
+   * Get documents by status
+   */
+  async getByStatus(status) {
+    const docs = await this.prisma.contextRagDocument.findMany({
+      where: { status },
+      orderBy: { createdAt: "desc" }
+    });
+    return docs.map((d) => this.mapToDocumentStatus(d));
+  }
+  /**
+   * Map database record to DocumentStatus type
+   */
+  mapToDocumentStatus(record) {
+    const totalBatches = record["totalBatches"];
+    const completedBatches = record["completedBatches"];
+    return {
+      id: record["id"],
+      filename: record["filename"],
+      status: record["status"],
+      documentType: record["documentType"],
+      pageCount: record["pageCount"],
+      progress: {
+        totalBatches,
+        completedBatches,
+        failedBatches: record["failedBatches"],
+        percentage: totalBatches > 0 ? Math.round(completedBatches / totalBatches * 100) : 0
+      },
+      tokenUsage: record["tokenUsage"],
+      processingMs: record["processingMs"],
+      error: record["errorMessage"],
+      createdAt: record["createdAt"],
+      completedAt: record["completedAt"]
+    };
+  }
+};
+
+// src/database/repositories/batch.repository.ts
+var BatchRepository = class {
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  /**
+   * Create multiple batches for a document
+   */
+  async createMany(inputs) {
+    try {
+      await this.prisma.contextRagBatch.createMany({
+        data: inputs.map((input) => ({
+          documentId: input.documentId,
+          batchIndex: input.batchIndex,
+          pageStart: input.pageStart,
+          pageEnd: input.pageEnd,
+          status: BatchStatusEnum.PENDING
+        }))
+      });
+    } catch (error) {
+      throw new DatabaseError("Failed to create batches", {
+        error: error.message
+      });
+    }
+  }
+  /**
+   * Get batch by ID
+   */
+  async getById(id) {
+    const batch = await this.prisma.contextRagBatch.findUnique({
+      where: { id }
+    });
+    if (!batch) {
+      throw new NotFoundError("Batch", id);
+    }
+    return this.mapToBatchRecord(batch);
+  }
+  /**
+   * Get all batches for a document
+   */
+  async getByDocumentId(documentId) {
+    const batches = await this.prisma.contextRagBatch.findMany({
+      where: { documentId },
+      orderBy: { batchIndex: "asc" }
+    });
+    return batches.map((b) => this.mapToBatchRecord(b));
+  }
+  /**
+   * Get pending batches for a document
+   */
+  async getPending(documentId) {
+    const batches = await this.prisma.contextRagBatch.findMany({
+      where: {
+        documentId,
+        status: BatchStatusEnum.PENDING
+      },
+      orderBy: { batchIndex: "asc" }
+    });
+    return batches.map((b) => this.mapToBatchRecord(b));
+  }
+  /**
+   * Get failed batches for retry
+   */
+  async getFailed(documentId, maxRetries) {
+    const batches = await this.prisma.contextRagBatch.findMany({
+      where: {
+        documentId,
+        status: BatchStatusEnum.FAILED,
+        retryCount: { lt: maxRetries }
+      },
+      orderBy: { batchIndex: "asc" }
+    });
+    return batches.map((b) => this.mapToBatchRecord(b));
+  }
+  /**
+   * Mark batch as processing
+   */
+  async markProcessing(id) {
+    await this.prisma.contextRagBatch.update({
+      where: { id },
+      data: {
+        status: BatchStatusEnum.PROCESSING,
+        startedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  /**
+   * Mark batch as retrying
+   */
+  async markRetrying(id, error) {
+    await this.prisma.contextRagBatch.update({
+      where: { id },
+      data: {
+        status: BatchStatusEnum.RETRYING,
+        lastError: error,
+        retryCount: { increment: 1 }
+      }
+    });
+  }
+  /**
+   * Mark batch as completed
+   */
+  async markCompleted(id, tokenUsage, processingMs) {
+    await this.prisma.contextRagBatch.update({
+      where: { id },
+      data: {
+        status: BatchStatusEnum.COMPLETED,
+        tokenUsage,
+        processingMs,
+        completedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  /**
+   * Mark batch as failed
+   */
+  async markFailed(id, error) {
+    await this.prisma.contextRagBatch.update({
+      where: { id },
+      data: {
+        status: BatchStatusEnum.FAILED,
+        lastError: error,
+        completedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  /**
+   * Reset batch for retry (set back to pending)
+   */
+  async resetForRetry(id) {
+    await this.prisma.contextRagBatch.update({
+      where: { id },
+      data: {
+        status: BatchStatusEnum.PENDING,
+        startedAt: null,
+        completedAt: null
+      }
+    });
+  }
+  /**
+   * Map database record to BatchRecord type
+   */
+  mapToBatchRecord(record) {
+    return {
+      id: record["id"],
+      documentId: record["documentId"],
+      batchIndex: record["batchIndex"],
+      pageStart: record["pageStart"],
+      pageEnd: record["pageEnd"],
+      status: record["status"],
+      retryCount: record["retryCount"],
+      lastError: record["lastError"],
+      tokenUsage: record["tokenUsage"],
+      processingMs: record["processingMs"],
+      startedAt: record["startedAt"],
+      completedAt: record["completedAt"],
+      createdAt: record["createdAt"]
+    };
+  }
+};
+
+// src/database/repositories/chunk.repository.ts
+var ChunkRepository = class {
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  /**
+   * Create a single chunk with embedding
+   */
+  async create(input, embedding) {
+    try {
+      const result = await this.prisma.$queryRaw`
+        INSERT INTO context_rag_chunks (
+          id, prompt_config_id, document_id, chunk_index, chunk_type,
+          search_content, search_vector, display_content,
+          source_page_start, source_page_end, confidence_score, metadata, created_at
+        ) VALUES (
+          gen_random_uuid(),
+          ${input.promptConfigId},
+          ${input.documentId},
+          ${input.chunkIndex},
+          ${input.chunkType},
+          ${input.searchContent},
+          ${embedding}::vector,
+          ${input.displayContent},
+          ${input.sourcePageStart},
+          ${input.sourcePageEnd},
+          ${input.confidenceScore},
+          ${JSON.stringify(input.metadata)}::jsonb,
+          NOW()
+        )
+        RETURNING id
+      `;
+      return result[0]?.id ?? "";
+    } catch (error) {
+      throw new DatabaseError("Failed to create chunk", {
+        error: error.message
+      });
+    }
+  }
+  /**
+   * Create multiple chunks with embeddings
+   */
+  async createMany(inputs, embeddings) {
+    const ids = [];
+    await this.prisma.$transaction(async (tx) => {
+      for (let i = 0; i < inputs.length; i++) {
+        const input = inputs[i];
+        const embedding = embeddings[i];
+        if (!input || !embedding) continue;
+        const result = await tx.$queryRaw`
+          INSERT INTO context_rag_chunks (
+            id, prompt_config_id, document_id, chunk_index, chunk_type,
+            search_content, search_vector, display_content,
+            source_page_start, source_page_end, confidence_score, metadata, created_at
+          ) VALUES (
+            gen_random_uuid(),
+            ${input.promptConfigId},
+            ${input.documentId},
+            ${input.chunkIndex},
+            ${input.chunkType},
+            ${input.searchContent},
+            ${embedding}::vector,
+            ${input.displayContent},
+            ${input.sourcePageStart},
+            ${input.sourcePageEnd},
+            ${input.confidenceScore},
+            ${JSON.stringify(input.metadata)}::jsonb,
+            NOW()
+          )
+          RETURNING id
+        `;
+        const id = result[0]?.id;
+        if (id) ids.push(id);
+      }
+    });
+    return ids;
+  }
+  /**
+   * Vector similarity search
+   */
+  async searchSemantic(queryEmbedding, limit, filters, minScore) {
+    const whereConditions = [];
+    const params = [queryEmbedding, limit];
+    let paramIndex = 3;
+    if (filters?.documentTypes?.length) {
+      whereConditions.push(`c.document_id IN (
+        SELECT id FROM context_rag_documents WHERE document_type = ANY($${paramIndex})
+      )`);
+      params.push(filters.documentTypes);
+      paramIndex++;
+    }
+    if (filters?.chunkTypes?.length) {
+      whereConditions.push(`c.chunk_type = ANY($${paramIndex})`);
+      params.push(filters.chunkTypes);
+      paramIndex++;
+    }
+    if (filters?.minConfidence !== void 0) {
+      whereConditions.push(`c.confidence_score >= $${paramIndex}`);
+      params.push(filters.minConfidence);
+      paramIndex++;
+    }
+    if (filters?.documentIds?.length) {
+      whereConditions.push(`c.document_id = ANY($${paramIndex})`);
+      params.push(filters.documentIds);
+      paramIndex++;
+    }
+    if (filters?.promptConfigIds?.length) {
+      whereConditions.push(`c.prompt_config_id = ANY($${paramIndex})`);
+      params.push(filters.promptConfigIds);
+      paramIndex++;
+    }
+    const whereClause = whereConditions.length > 0 ? `WHERE ${whereConditions.join(" AND ")}` : "";
+    const scoreThreshold = minScore !== void 0 ? `HAVING 1 - (c.search_vector <=> $1::vector) >= ${minScore}` : "";
+    const query = `
+      SELECT 
+        c.id, c.prompt_config_id, c.document_id, c.chunk_index, c.chunk_type,
+        c.search_content, c.display_content,
+        c.source_page_start, c.source_page_end, c.confidence_score,
+        c.metadata, c.created_at,
+        1 - (c.search_vector <=> $1::vector) as similarity
+      FROM context_rag_chunks c
+      ${whereClause}
+      GROUP BY c.id
+      ${scoreThreshold}
+      ORDER BY c.search_vector <=> $1::vector
+      LIMIT $2
+    `;
+    const results = await this.prisma.$queryRawUnsafe(query, ...params);
+    return results.map((row) => ({
+      chunk: this.mapToVectorChunk(row),
+      similarity: row["similarity"]
+    }));
+  }
+  /**
+   * Full-text keyword search
+   */
+  async searchKeyword(query, limit, filters) {
+    const whereConditions = [
+      `to_tsvector('english', c.search_content) @@ plainto_tsquery('english', $1)`
+    ];
+    const params = [query, limit];
+    let paramIndex = 3;
+    if (filters?.chunkTypes?.length) {
+      whereConditions.push(`c.chunk_type = ANY($${paramIndex})`);
+      params.push(filters.chunkTypes);
+      paramIndex++;
+    }
+    if (filters?.documentIds?.length) {
+      whereConditions.push(`c.document_id = ANY($${paramIndex})`);
+      params.push(filters.documentIds);
+      paramIndex++;
+    }
+    const whereClause = `WHERE ${whereConditions.join(" AND ")}`;
+    const queryStr = `
+      SELECT 
+        c.id, c.prompt_config_id, c.document_id, c.chunk_index, c.chunk_type,
+        c.search_content, c.display_content,
+        c.source_page_start, c.source_page_end, c.confidence_score,
+        c.metadata, c.created_at,
+        ts_rank(to_tsvector('english', c.search_content), plainto_tsquery('english', $1)) as similarity
+      FROM context_rag_chunks c
+      ${whereClause}
+      ORDER BY similarity DESC
+      LIMIT $2
+    `;
+    const results = await this.prisma.$queryRawUnsafe(queryStr, ...params);
+    return results.map((row) => ({
+      chunk: this.mapToVectorChunk(row),
+      similarity: row["similarity"]
+    }));
+  }
+  /**
+   * Get chunks by document ID
+   */
+  async getByDocumentId(documentId) {
+    const chunks = await this.prisma.contextRagChunk.findMany({
+      where: { documentId },
+      orderBy: { chunkIndex: "asc" }
+    });
+    return chunks.map((c) => this.mapToVectorChunk(c));
+  }
+  /**
+   * Delete chunks by document ID
+   */
+  async deleteByDocumentId(documentId) {
+    const result = await this.prisma.contextRagChunk.deleteMany({
+      where: { documentId }
+    });
+    return result.count;
+  }
+  /**
+   * Count chunks by document ID
+   */
+  async countByDocumentId(documentId) {
+    return await this.prisma.contextRagChunk.count({
+      where: { documentId }
+    });
+  }
+  /**
+   * Map database record to VectorChunk type
+   */
+  mapToVectorChunk(record) {
+    return {
+      id: record["id"],
+      promptConfigId: record["prompt_config_id"] ?? record["promptConfigId"],
+      documentId: record["document_id"] ?? record["documentId"],
+      chunkIndex: record["chunk_index"] ?? record["chunkIndex"],
+      chunkType: record["chunk_type"] ?? record["chunkType"],
+      searchContent: record["search_content"] ?? record["searchContent"],
+      displayContent: record["display_content"] ?? record["displayContent"],
+      sourcePageStart: record["source_page_start"] ?? record["sourcePageStart"],
+      sourcePageEnd: record["source_page_end"] ?? record["sourcePageEnd"],
+      confidenceScore: record["confidence_score"] ?? record["confidenceScore"],
+      metadata: record["metadata"],
+      createdAt: record["created_at"] ?? record["createdAt"]
+    };
+  }
+};
+
+// src/database/utils.ts
+async function checkPgVectorExtension(prisma) {
+  try {
+    const result = await prisma.$queryRaw`
+      SELECT EXISTS (
+        SELECT 1 FROM pg_extension WHERE extname = 'vector'
+      ) as exists
+    `;
+    return result[0]?.exists ?? false;
+  } catch (error) {
+    throw new DatabaseError("Failed to check pgvector extension", {
+      error: error.message
+    });
+  }
+}
+async function checkDatabaseConnection(prisma) {
+  try {
+    await prisma.$queryRaw`SELECT 1`;
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getDatabaseStats(prisma) {
+  try {
+    const [documents, chunks, promptConfigs, batches] = await Promise.all([
+      prisma.contextRagDocument.count(),
+      prisma.contextRagChunk.count(),
+      prisma.contextRagPromptConfig.count(),
+      prisma.contextRagBatch.count()
+    ]);
+    const storageResult = await prisma.$queryRaw`
+      SELECT 
+        COALESCE(SUM(pg_total_relation_size(quote_ident(tablename)::regclass)), 0) as total_bytes
+      FROM pg_tables
+      WHERE tablename LIKE 'context_rag_%'
+    `;
+    const totalStorageBytes = Number(storageResult[0]?.total_bytes ?? 0);
+    return {
+      documents,
+      chunks,
+      promptConfigs,
+      batches,
+      totalStorageBytes
+    };
+  } catch (error) {
+    throw new DatabaseError("Failed to get database stats", {
+      error: error.message
+    });
+  }
+}
+var GeminiService = class {
+  genAI;
+  fileManager;
+  model;
+  embeddingModel;
+  config;
+  rateLimiter;
+  logger;
+  constructor(config, rateLimiter, logger) {
+    this.genAI = new generativeAi.GoogleGenerativeAI(config.geminiApiKey);
+    this.fileManager = new server.GoogleAIFileManager(config.geminiApiKey);
+    this.model = this.genAI.getGenerativeModel({ model: config.model });
+    this.embeddingModel = this.genAI.getGenerativeModel({ model: config.embeddingModel });
+    this.config = config;
+    this.rateLimiter = rateLimiter;
+    this.logger = logger;
+  }
+  /**
+   * Generate text content
+   */
+  async generate(systemPrompt, userContent, options) {
+    await this.rateLimiter.acquire();
+    try {
+      const result = await this.model.generateContent({
+        contents: [
+          {
+            role: "user",
+            parts: [{ text: `${systemPrompt}
+
+${userContent}` }]
+          }
+        ],
+        generationConfig: {
+          temperature: options?.temperature ?? this.config.generationConfig.temperature,
+          maxOutputTokens: options?.maxOutputTokens ?? this.config.generationConfig.maxOutputTokens
+        }
+      });
+      const response = result.response;
+      const text = response.text();
+      const usage = response.usageMetadata;
+      this.rateLimiter.reportSuccess();
+      return {
+        text,
+        tokenUsage: {
+          input: usage?.promptTokenCount ?? 0,
+          output: usage?.candidatesTokenCount ?? 0,
+          total: usage?.totalTokenCount ?? 0
+        }
+      };
+    } catch (error) {
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * Generate content with vision (PDF pages as images)
+   */
+  async generateWithVision(systemPrompt, parts, options) {
+    await this.rateLimiter.acquire();
+    try {
+      const result = await this.model.generateContent({
+        contents: [
+          {
+            role: "user",
+            parts: [{ text: systemPrompt }, ...parts]
+          }
+        ],
+        generationConfig: {
+          temperature: options?.temperature ?? this.config.generationConfig.temperature,
+          maxOutputTokens: options?.maxOutputTokens ?? this.config.generationConfig.maxOutputTokens
+        }
+      });
+      const response = result.response;
+      const text = response.text();
+      const usage = response.usageMetadata;
+      this.rateLimiter.reportSuccess();
+      return {
+        text,
+        tokenUsage: {
+          input: usage?.promptTokenCount ?? 0,
+          output: usage?.candidatesTokenCount ?? 0,
+          total: usage?.totalTokenCount ?? 0
+        }
+      };
+    } catch (error) {
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * Generate embeddings for text with task type
+   * 
+   * Best practices:
+   * - Use RETRIEVAL_DOCUMENT for documents being indexed
+   * - Use RETRIEVAL_QUERY for search queries
+   * 
+   * @see https://ai.google.dev/gemini-api/docs/embeddings
+   */
+  async embed(text, taskType = "RETRIEVAL_DOCUMENT") {
+    await this.rateLimiter.acquire();
+    try {
+      const result = await this.embeddingModel.embedContent({
+        content: { parts: [{ text }], role: "user" },
+        taskType: this.mapTaskType(taskType)
+      });
+      this.rateLimiter.reportSuccess();
+      return {
+        embedding: result.embedding.values,
+        tokenCount: text.split(/\s+/).length
+        // Approximate
+      };
+    } catch (error) {
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * Generate embeddings for documents (for indexing)
+   * Uses RETRIEVAL_DOCUMENT task type
+   */
+  async embedDocument(text) {
+    return this.embed(text, "RETRIEVAL_DOCUMENT");
+  }
+  /**
+   * Generate embeddings for search query
+   * Uses RETRIEVAL_QUERY task type
+   */
+  async embedQuery(text) {
+    return this.embed(text, "RETRIEVAL_QUERY");
+  }
+  /**
+   * Generate embeddings for multiple documents (batch)
+   * Uses RETRIEVAL_DOCUMENT task type
+   */
+  async embedBatch(texts) {
+    const results = [];
+    for (const text of texts) {
+      const result = await this.embedDocument(text);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Map our task type enum to Gemini's TaskType
+   */
+  mapTaskType(taskType) {
+    const mapping = {
+      "RETRIEVAL_DOCUMENT": generativeAi.TaskType.RETRIEVAL_DOCUMENT,
+      "RETRIEVAL_QUERY": generativeAi.TaskType.RETRIEVAL_QUERY,
+      "SEMANTIC_SIMILARITY": generativeAi.TaskType.SEMANTIC_SIMILARITY,
+      "CLASSIFICATION": generativeAi.TaskType.CLASSIFICATION,
+      "CLUSTERING": generativeAi.TaskType.CLUSTERING
+    };
+    return mapping[taskType];
+  }
+  /**
+   * Simple text generation (single prompt)
+   * Used for context generation in RAG enhancement
+   */
+  async generateSimple(prompt) {
+    await this.rateLimiter.acquire();
+    try {
+      const result = await this.model.generateContent({
+        contents: [
+          {
+            role: "user",
+            parts: [{ text: prompt }]
+          }
+        ],
+        generationConfig: {
+          temperature: 0.3,
+          maxOutputTokens: 200
+          // Short context
+        }
+      });
+      this.rateLimiter.reportSuccess();
+      return result.response.text().trim();
+    } catch (error) {
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * Generate content with file reference (for contextual retrieval)
+   * Uses Gemini's file caching for efficiency
+   */
+  async generateWithFileRef(fileUri, prompt) {
+    await this.rateLimiter.acquire();
+    try {
+      const result = await this.model.generateContent({
+        contents: [
+          {
+            role: "user",
+            parts: [
+              { fileData: { mimeType: "application/pdf", fileUri } },
+              { text: prompt }
+            ]
+          }
+        ],
+        generationConfig: {
+          temperature: 0.3,
+          maxOutputTokens: 200
+        }
+      });
+      this.rateLimiter.reportSuccess();
+      return result.response.text().trim();
+    } catch (error) {
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * Upload PDF buffer to Gemini Files API
+   * Returns file URI for use in subsequent requests
+   * File is cached by Gemini for efficient reuse
+   */
+  async uploadPdfBuffer(buffer, filename) {
+    try {
+      const fs2 = await import('fs');
+      const path2 = await import('path');
+      const os = await import('os');
+      const tempPath = path2.join(os.tmpdir(), `context-rag-${Date.now()}-${filename}`);
+      fs2.writeFileSync(tempPath, buffer);
+      this.logger.info("Uploading PDF to Gemini Files API", { filename });
+      const uploadResult = await this.fileManager.uploadFile(tempPath, {
+        mimeType: "application/pdf",
+        displayName: filename
+      });
+      fs2.unlinkSync(tempPath);
+      this.logger.info("PDF uploaded successfully", {
+        fileUri: uploadResult.file.uri,
+        displayName: uploadResult.file.displayName
+      });
+      return uploadResult.file.uri;
+    } catch (error) {
+      this.logger.error("Failed to upload PDF", { error: error.message });
+      throw error;
+    }
+  }
+  /**
+   * Generate content using uploaded PDF URI
+   * Uses Gemini's file caching for efficient context generation
+   */
+  async generateWithPdfUri(pdfUri, prompt, options) {
+    await this.rateLimiter.acquire();
+    try {
+      const result = await this.model.generateContent({
+        contents: [
+          {
+            role: "user",
+            parts: [
+              { fileData: { mimeType: "application/pdf", fileUri: pdfUri } },
+              { text: prompt }
+            ]
+          }
+        ],
+        generationConfig: {
+          temperature: options?.temperature ?? 0.3,
+          maxOutputTokens: options?.maxOutputTokens ?? 200
+        }
+      });
+      const response = result.response;
+      const text = response.text().trim();
+      const usage = response.usageMetadata;
+      this.rateLimiter.reportSuccess();
+      return {
+        text,
+        tokenUsage: {
+          input: usage?.promptTokenCount ?? 0,
+          output: usage?.candidatesTokenCount ?? 0,
+          total: usage?.totalTokenCount ?? 0
+        }
+      };
+    } catch (error) {
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * Handle API errors
+   */
+  handleError(error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("429") || message.includes("rate limit")) {
+      this.rateLimiter.reportRateLimitError();
+      throw new RateLimitError("Gemini API rate limit exceeded");
+    }
+    this.logger.error("Gemini API error", {
+      error: error.message
+    });
+  }
+};
+var PDFProcessor = class {
+  logger;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  /**
+   * Load PDF from file path or buffer
+   */
+  async load(input) {
+    let buffer;
+    let filename;
+    if (typeof input === "string") {
+      buffer = await fs__namespace.readFile(input);
+      filename = path__namespace.basename(input);
+    } else {
+      buffer = input;
+      filename = "document.pdf";
+    }
+    const fileHash = hashBuffer(buffer);
+    const fileSize = buffer.length;
+    const pdfData = await pdf__default.default(buffer);
+    const pageCount = pdfData.numpages;
+    this.logger.debug("PDF loaded", {
+      filename,
+      fileSize,
+      pageCount
+    });
+    return {
+      buffer,
+      metadata: {
+        filename,
+        fileHash,
+        fileSize,
+        pageCount,
+        title: pdfData.info?.Title,
+        author: pdfData.info?.Author
+      }
+    };
+  }
+  /**
+   * Extract text from all pages
+   */
+  async extractText(buffer) {
+    const pdfData = await pdf__default.default(buffer);
+    return [{
+      pageNumber: 1,
+      text: pdfData.text
+    }];
+  }
+  /**
+   * Convert PDF buffer to base64 for Gemini Vision API
+   */
+  toBase64(buffer) {
+    return buffer.toString("base64");
+  }
+  /**
+   * Create Gemini vision part from PDF
+   */
+  createVisionPart(buffer) {
+    return {
+      inlineData: {
+        mimeType: "application/pdf",
+        data: this.toBase64(buffer)
+      }
+    };
+  }
+  /**
+   * Split document into batches
+   */
+  createBatches(pageCount, pagesPerBatch) {
+    const batches = [];
+    for (let i = 0; i < pageCount; i += pagesPerBatch) {
+      batches.push({
+        batchIndex: batches.length,
+        pageStart: i + 1,
+        // 1-indexed
+        pageEnd: Math.min(i + pagesPerBatch, pageCount)
+      });
+    }
+    this.logger.debug("Created batches", {
+      pageCount,
+      pagesPerBatch,
+      batchCount: batches.length
+    });
+    return batches;
+  }
+  /**
+   * Get page range description for prompts
+   */
+  getPageRangeDescription(pageStart, pageEnd) {
+    if (pageStart === pageEnd) {
+      return `page ${pageStart}`;
+    }
+    return `pages ${pageStart}-${pageEnd}`;
+  }
+};
+
+// src/enhancements/no-op.handler.ts
+var NoOpHandler = class {
+  shouldSkip() {
+    return true;
+  }
+  async generateContext() {
+    return "";
+  }
+};
+
+// src/types/rag-enhancement.types.ts
+var DEFAULT_ANTHROPIC_CONFIG = {
+  skipChunkTypes: ["HEADING", "IMAGE_REF"],
+  concurrencyLimit: 5,
+  template: "[{documentType}] [{chunkType}] Page {page}",
+  contextPrompt: "Bu par\xE7ay\u0131 belgede konumland\u0131r. Par\xE7an\u0131n ne hakk\u0131nda oldu\u011Funu ve belgede nerede bulundu\u011Funu 1-2 c\xFCmle ile T\xFCrk\xE7e a\xE7\u0131kla:"
+};
+var AnthropicHandler = class {
+  config;
+  gemini;
+  limit;
+  skipTypes;
+  constructor(config, gemini) {
+    this.config = config;
+    this.gemini = gemini;
+    this.limit = pLimit__default.default(config.concurrencyLimit ?? DEFAULT_ANTHROPIC_CONFIG.concurrencyLimit);
+    this.skipTypes = new Set(config.skipChunkTypes ?? DEFAULT_ANTHROPIC_CONFIG.skipChunkTypes);
+  }
+  shouldSkip(chunkType) {
+    return this.skipTypes.has(chunkType);
+  }
+  async generateContext(chunk, doc) {
+    if (this.shouldSkip(chunk.chunkType)) {
+      return "";
+    }
+    switch (this.config.strategy) {
+      case "none":
+        return "";
+      case "simple":
+        return this.generateSimpleContext(chunk, doc);
+      case "llm":
+        return this.limit(() => this.generateLLMContext(chunk, doc));
+      default:
+        return "";
+    }
+  }
+  /**
+   * Simple template-based context generation (free)
+   */
+  generateSimpleContext(chunk, doc) {
+    const template = this.config.template ?? DEFAULT_ANTHROPIC_CONFIG.template;
+    return template.replace("{documentType}", doc.documentType ?? "Document").replace("{chunkType}", chunk.chunkType).replace("{page}", String(chunk.page)).replace("{parentHeading}", chunk.parentHeading ?? "");
+  }
+  /**
+   * LLM-based context generation (best quality, ~$0.005/chunk)
+   */
+  async generateLLMContext(chunk, doc) {
+    const prompt = this.config.contextPrompt ?? DEFAULT_ANTHROPIC_CONFIG.contextPrompt;
+    const fullPrompt = `${prompt}
+
+<document_info>
+Dosya: ${doc.filename}
+Tip: ${doc.documentType ?? "Bilinmiyor"}
+Toplam Sayfa: ${doc.pageCount}
+</document_info>
+
+${doc.fullDocumentText ? `<full_document>
+${doc.fullDocumentText.slice(0, 15e3)}
+</full_document>
+
+` : ""}<chunk_to_contextualize>
+${chunk.content}
+</chunk_to_contextualize>
+
+Bu chunk'\u0131n belgede nerede oldu\u011Funu ve ne hakk\u0131nda oldu\u011Funu 1-2 c\xFCmle ile T\xFCrk\xE7e a\xE7\u0131kla:`;
+    try {
+      if (doc.fileUri) {
+        const chunkPrompt = `Bu chunk'\u0131n belgede nerede oldu\u011Funu ve ne hakk\u0131nda oldu\u011Funu 1-2 c\xFCmle ile T\xFCrk\xE7e a\xE7\u0131kla:
+
+<chunk>
+${chunk.content}
+</chunk>`;
+        const result2 = await this.gemini.generateWithPdfUri(doc.fileUri, chunkPrompt);
+        return result2.text;
+      }
+      const result = await this.gemini.generateSimple(fullPrompt);
+      return result;
+    } catch (error) {
+      console.warn("LLM context generation failed, using simple context:", error);
+      return this.generateSimpleContext(chunk, doc);
+    }
+  }
+};
+
+// src/enhancements/enhancement-registry.ts
+function createEnhancementHandler(config, resolvedConfig, gemini) {
+  if (!config || config.approach === "none") {
+    return new NoOpHandler();
+  }
+  switch (config.approach) {
+    case "anthropic_contextual":
+      return new AnthropicHandler(config, gemini);
+    case "google_grounding":
+      throw new Error("Google Grounding is not yet implemented");
+    case "custom":
+      return new CustomHandler(config.handler, config.skipChunkTypes);
+    default:
+      throw new Error(`Unknown RAG enhancement approach: ${config.approach}`);
+  }
+}
+var CustomHandler = class {
+  constructor(handler, skipChunkTypes) {
+    this.handler = handler;
+    this.skipChunkTypes = skipChunkTypes;
+  }
+  shouldSkip(chunkType) {
+    return this.skipChunkTypes?.includes(chunkType) ?? false;
+  }
+  async generateContext(chunk, doc) {
+    if (this.shouldSkip(chunk.chunkType)) {
+      return "";
+    }
+    return this.handler({ chunk, doc });
+  }
+};
+
+// src/engines/ingestion.engine.ts
+var IngestionEngine = class {
+  config;
+  prisma;
+  gemini;
+  pdfProcessor;
+  documentRepo;
+  batchRepo;
+  chunkRepo;
+  promptConfigRepo;
+  logger;
+  enhancementHandler;
+  constructor(config, rateLimiter, logger) {
+    this.config = config;
+    this.prisma = config.prisma;
+    this.gemini = new GeminiService(config, rateLimiter, logger);
+    this.pdfProcessor = new PDFProcessor(logger);
+    this.documentRepo = new DocumentRepository(this.prisma);
+    this.batchRepo = new BatchRepository(this.prisma);
+    this.chunkRepo = new ChunkRepository(this.prisma);
+    this.promptConfigRepo = new PromptConfigRepository(this.prisma);
+    this.logger = logger;
+    this.enhancementHandler = createEnhancementHandler(
+      config.ragEnhancement,
+      config,
+      this.gemini
+    );
+  }
+  /**
+   * Ingest a document
+   */
+  async ingest(options) {
+    const startTime = Date.now();
+    this.logger.info("Starting ingestion", {
+      documentType: options.documentType
+    });
+    const { buffer, metadata } = await this.pdfProcessor.load(options.file);
+    const fileUri = await this.gemini.uploadPdfBuffer(buffer, metadata.filename);
+    if (options.skipExisting) {
+      const existing = await this.documentRepo.getByHashAndExperiment(
+        metadata.fileHash,
+        options.experimentId
+      );
+      if (existing) {
+        this.logger.info("Document already exists for this experiment, skipping", {
+          documentId: existing.id,
+          experimentId: options.experimentId
+        });
+        return {
+          documentId: existing.id,
+          status: existing.status,
+          chunkCount: 0,
+          batchCount: existing.progress.totalBatches,
+          failedBatchCount: existing.progress.failedBatches,
+          tokenUsage: existing.tokenUsage ?? { input: 0, output: 0, total: 0 },
+          processingMs: 0,
+          batches: [],
+          warnings: ["Document already exists for this experiment, skipped processing"]
+        };
+      }
+    }
+    let documentInstructions = [];
+    let exampleFormats;
+    let promptConfigId = options.promptConfigId;
+    if (!promptConfigId && options.documentType) {
+      const promptConfig = await this.promptConfigRepo.getDefault(options.documentType);
+      if (promptConfig) {
+        promptConfigId = promptConfig.id;
+        documentInstructions = promptConfig.systemPrompt.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+      }
+    }
+    if (options.customPrompt) {
+      documentInstructions = options.customPrompt.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+    } else if (documentInstructions.length === 0) {
+      documentInstructions = DEFAULT_DOCUMENT_INSTRUCTIONS.split("\n").map((line) => line.replace(/^-\s*/, "").trim()).filter((line) => line.length > 0);
+    }
+    const batchSpecs = this.pdfProcessor.createBatches(
+      metadata.pageCount,
+      this.config.batchConfig.pagesPerBatch
+    );
+    const documentId = await this.documentRepo.create({
+      filename: options.filename ?? metadata.filename,
+      fileHash: metadata.fileHash,
+      fileSize: metadata.fileSize,
+      pageCount: metadata.pageCount,
+      documentType: options.documentType,
+      promptConfigId,
+      totalBatches: batchSpecs.length,
+      experimentId: options.experimentId,
+      modelName: this.config.model,
+      modelConfig: {
+        temperature: this.config.generationConfig?.temperature,
+        maxOutputTokens: this.config.generationConfig?.maxOutputTokens
+      }
+    });
+    await this.batchRepo.createMany(
+      batchSpecs.map((spec) => ({
+        documentId,
+        batchIndex: spec.batchIndex,
+        pageStart: spec.pageStart,
+        pageEnd: spec.pageEnd
+      }))
+    );
+    await this.documentRepo.update(documentId, {
+      status: DocumentStatusEnum.PROCESSING
+    });
+    const batchResults = await this.processBatchesConcurrently(
+      documentId,
+      // buffer removed
+      documentInstructions,
+      exampleFormats,
+      promptConfigId ?? "default",
+      fileUri,
+      metadata.filename,
+      options.onProgress
+    );
+    const totalTokenUsage = {
+      input: 0,
+      output: 0,
+      total: 0
+    };
+    let totalChunks = 0;
+    let failedCount = 0;
+    for (const result of batchResults) {
+      totalTokenUsage.input += result.tokenUsage.input;
+      totalTokenUsage.output += result.tokenUsage.output;
+      totalTokenUsage.total += result.tokenUsage.total;
+      totalChunks += result.chunksCreated;
+      if (result.status === BatchStatusEnum.FAILED) {
+        failedCount++;
+      }
+    }
+    const processingMs = Date.now() - startTime;
+    await this.documentRepo.markCompleted(documentId, totalTokenUsage, processingMs);
+    const status = failedCount > 0 ? DocumentStatusEnum.PARTIAL : DocumentStatusEnum.COMPLETED;
+    this.logger.info("Ingestion completed", {
+      documentId,
+      status,
+      chunkCount: totalChunks,
+      batchCount: batchSpecs.length,
+      failedBatchCount: failedCount,
+      processingMs
+    });
+    return {
+      documentId,
+      status,
+      chunkCount: totalChunks,
+      batchCount: batchSpecs.length,
+      failedBatchCount: failedCount,
+      tokenUsage: totalTokenUsage,
+      processingMs,
+      batches: batchResults,
+      warnings: failedCount > 0 ? [`${failedCount} batch(es) failed to process`] : void 0
+    };
+  }
+  /**
+   * Process batches with concurrency control
+   */
+  async processBatchesConcurrently(documentId, documentInstructions, exampleFormats, promptConfigId, fileUri, filename, onProgress) {
+    const batches = await this.batchRepo.getByDocumentId(documentId);
+    const results = [];
+    const { maxConcurrency } = this.config.batchConfig;
+    for (let i = 0; i < batches.length; i += maxConcurrency) {
+      const currentBatch = batches.slice(i, i + maxConcurrency);
+      const batchPromises = currentBatch.map(
+        (batch) => this.processSingleBatch(
+          batch,
+          // pdfBuffer removed
+          documentInstructions,
+          exampleFormats,
+          promptConfigId,
+          fileUri,
+          filename,
+          documentId,
+          batches.length,
+          onProgress
+        )
+      );
+      const batchResults = await Promise.all(batchPromises);
+      results.push(...batchResults);
+    }
+    return results;
+  }
+  /**
+   * Process a single batch with retry logic
+   */
+  async processSingleBatch(batch, documentInstructions, exampleFormats, promptConfigId, fileUri, filename, documentId, totalBatches, onProgress) {
+    const startTime = Date.now();
+    onProgress?.({
+      current: batch.batchIndex + 1,
+      total: totalBatches,
+      status: BatchStatusEnum.PROCESSING,
+      pageRange: { start: batch.pageStart, end: batch.pageEnd }
+    });
+    await this.batchRepo.markProcessing(batch.id);
+    const retryOptions = getRetryOptions(this.config.batchConfig);
+    let retryCount = 0;
+    try {
+      const result = await withRetry(
+        async () => {
+          const prompt = buildExtractionPrompt(
+            documentInstructions,
+            exampleFormats,
+            batch.pageStart,
+            batch.pageEnd
+          );
+          const fullPrompt = `${prompt}
+                    
+                    IMPORTANT: You have the FULL document. Restrict your extraction STRICTLY to pages ${batch.pageStart} to ${batch.pageEnd}. Do not extract content from other pages.`;
+          const response = await this.gemini.generateWithPdfUri(
+            fileUri,
+            fullPrompt,
+            {
+              temperature: this.config.generationConfig?.temperature,
+              maxOutputTokens: this.config.generationConfig?.maxOutputTokens
+            }
+          );
+          return response;
+        },
+        {
+          ...retryOptions,
+          onRetry: (attempt, error) => {
+            retryCount = attempt;
+            this.logger.warn("Batch retry", {
+              batchId: batch.id,
+              attempt,
+              error: error.message
+            });
+            onProgress?.({
+              current: batch.batchIndex + 1,
+              total: totalBatches,
+              status: BatchStatusEnum.RETRYING,
+              pageRange: { start: batch.pageStart, end: batch.pageEnd },
+              retryCount: attempt
+            });
+          }
+        }
+      );
+      const chunks = this.parseContentToChunks(
+        result.text,
+        promptConfigId,
+        documentId,
+        batch.pageStart,
+        batch.pageEnd
+      );
+      const docContext = {
+        documentType: void 0,
+        // Inferred from processing
+        filename,
+        pageCount: batch.pageEnd,
+        // Approximate from batch
+        fileUri
+        // Pass the Files API URI for context generation
+      };
+      for (const chunk of chunks) {
+        const chunkData = {
+          content: chunk.displayContent,
+          searchContent: chunk.searchContent,
+          displayContent: chunk.displayContent,
+          chunkType: chunk.chunkType,
+          page: chunk.sourcePageStart,
+          parentHeading: void 0
+          // Could be extracted from metadata
+        };
+        const context = await this.enhancementHandler.generateContext(chunkData, docContext);
+        if (context) {
+          chunk.contextText = context;
+          const enriched = `${context} ${chunk.searchContent}`;
+          chunk.enrichedContent = enriched;
+          chunk.searchContent = enriched;
+        }
+      }
+      const textsToEmbed = chunks.map(
+        (c) => c.enrichedContent ?? c.searchContent
+      );
+      const embeddings = await this.gemini.embedBatch(textsToEmbed);
+      await this.chunkRepo.createMany(
+        chunks,
+        embeddings.map((e) => e.embedding)
+      );
+      const processingMs = Date.now() - startTime;
+      await this.batchRepo.markCompleted(batch.id, result.tokenUsage, processingMs);
+      await this.documentRepo.incrementCompleted(documentId);
+      onProgress?.({
+        current: batch.batchIndex + 1,
+        total: totalBatches,
+        status: BatchStatusEnum.COMPLETED,
+        pageRange: { start: batch.pageStart, end: batch.pageEnd }
+      });
+      return {
+        batchIndex: batch.batchIndex,
+        status: BatchStatusEnum.COMPLETED,
+        chunksCreated: chunks.length,
+        tokenUsage: result.tokenUsage,
+        processingMs,
+        retryCount
+      };
+    } catch (error) {
+      const errorMessage = error.message;
+      await this.batchRepo.markFailed(batch.id, errorMessage);
+      await this.documentRepo.incrementFailed(documentId);
+      onProgress?.({
+        current: batch.batchIndex + 1,
+        total: totalBatches,
+        status: BatchStatusEnum.FAILED,
+        pageRange: { start: batch.pageStart, end: batch.pageEnd },
+        error: errorMessage
+      });
+      this.logger.error("Batch failed", {
+        batchId: batch.id,
+        error: errorMessage
+      });
+      return {
+        batchIndex: batch.batchIndex,
+        status: BatchStatusEnum.FAILED,
+        chunksCreated: 0,
+        tokenUsage: { input: 0, output: 0, total: 0 },
+        processingMs: Date.now() - startTime,
+        retryCount,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * Parse extracted content into chunks
+   * Uses structured <!-- SECTION --> markers when available,
+   * falls back to legacy parsing for compatibility.
+   */
+  parseContentToChunks(content, promptConfigId, documentId, pageStart, pageEnd) {
+    const chunks = [];
+    if (hasValidSections(content)) {
+      const sections2 = parseSections(content);
+      this.logger.debug("Using structured section parser", {
+        sectionCount: sections2.length
+      });
+      for (const section of sections2) {
+        if (section.content.length < 10) continue;
+        chunks.push({
+          promptConfigId,
+          documentId,
+          chunkIndex: section.index,
+          chunkType: section.type,
+          searchContent: cleanForSearch(section.content),
+          displayContent: section.content,
+          sourcePageStart: section.page,
+          sourcePageEnd: section.page,
+          confidenceScore: section.confidence,
+          metadata: {
+            type: section.type,
+            pageRange: { start: section.page, end: section.page },
+            confidence: {
+              score: section.confidence,
+              category: section.confidence >= 0.8 ? "HIGH" : section.confidence >= 0.5 ? "MEDIUM" : "LOW"
+            },
+            parsedWithStructuredMarkers: true
+          }
+        });
+      }
+      return chunks;
+    }
+    this.logger.debug("Using fallback parser (no structured markers found)");
+    const sections = parseFallbackContent(content, pageStart);
+    for (const section of sections) {
+      if (section.content.length < 10) continue;
+      chunks.push({
+        promptConfigId,
+        documentId,
+        chunkIndex: section.index,
+        chunkType: section.type,
+        searchContent: cleanForSearch(section.content),
+        displayContent: section.content,
+        sourcePageStart: pageStart,
+        sourcePageEnd: pageEnd,
+        confidenceScore: section.confidence,
+        metadata: {
+          type: section.type,
+          pageRange: { start: pageStart, end: pageEnd },
+          confidence: { score: section.confidence, category: "MEDIUM" },
+          parsedWithStructuredMarkers: false
+        }
+      });
+    }
+    return chunks;
+  }
+};
+
+// src/engines/retrieval.engine.ts
+var RetrievalEngine = class {
+  chunkRepo;
+  gemini;
+  logger;
+  constructor(config, rateLimiter, logger) {
+    this.chunkRepo = new ChunkRepository(config.prisma);
+    this.gemini = new GeminiService(config, rateLimiter, logger);
+    this.logger = logger;
+  }
+  /**
+   * Search for relevant content
+   * Note: HEADING chunks are excluded by default. Use filters.chunkTypes to include them.
+   */
+  async search(options) {
+    const startTime = Date.now();
+    const mode = options.mode ?? SearchModeEnum.HYBRID;
+    const limit = options.limit ?? 10;
+    const filters = {
+      ...options.filters
+    };
+    if (!filters.chunkTypes) {
+      filters.chunkTypes = ["TEXT", "TABLE", "LIST", "CODE", "QUOTE", "IMAGE_REF", "QUESTION", "MIXED"];
+    }
+    this.logger.debug("Starting search", {
+      query: options.query.substring(0, 50),
+      mode,
+      limit
+    });
+    let results;
+    switch (mode) {
+      case SearchModeEnum.SEMANTIC:
+        results = await this.semanticSearch(options.query, limit, filters, options.minScore);
+        break;
+      case SearchModeEnum.KEYWORD:
+        results = await this.keywordSearch(options.query, limit, filters);
+        break;
+      case SearchModeEnum.HYBRID:
+      default:
+        results = await this.hybridSearch(options.query, limit, filters, options.minScore);
+        break;
+    }
+    if (options.typeBoost) {
+      results = this.applyTypeBoost(results, options.typeBoost);
+    }
+    if (options.includeExplanation) {
+      results = results.map((r) => ({
+        ...r,
+        explanation: {
+          matchType: mode === SearchModeEnum.HYBRID ? "both" : mode === SearchModeEnum.SEMANTIC ? "semantic" : "keyword",
+          rawScores: {
+            semantic: r.score
+          }
+        }
+      }));
+    }
+    this.logger.debug("Search completed", {
+      resultCount: results.length,
+      processingTimeMs: Date.now() - startTime
+    });
+    return results;
+  }
+  /**
+   * Search with full metadata response
+   */
+  async searchWithMetadata(options) {
+    const startTime = Date.now();
+    const results = await this.search(options);
+    return {
+      results,
+      metadata: {
+        totalFound: results.length,
+        processingTimeMs: Date.now() - startTime,
+        searchMode: options.mode ?? SearchModeEnum.HYBRID
+      }
+    };
+  }
+  /**
+   * Semantic search using vector similarity
+   */
+  async semanticSearch(query, limit, filters, minScore) {
+    const { embedding } = await this.gemini.embedQuery(query);
+    const results = await this.chunkRepo.searchSemantic(
+      embedding,
+      limit,
+      filters,
+      minScore
+    );
+    return results.map((r) => ({
+      chunk: r.chunk,
+      score: r.similarity
+    }));
+  }
+  /**
+   * Keyword-based search using full-text search
+   */
+  async keywordSearch(query, limit, filters) {
+    const results = await this.chunkRepo.searchKeyword(query, limit, filters);
+    return results.map((r) => ({
+      chunk: r.chunk,
+      score: r.similarity
+    }));
+  }
+  /**
+   * Hybrid search combining semantic and keyword
+   */
+  async hybridSearch(query, limit, filters, minScore) {
+    const [semanticResults, keywordResults] = await Promise.all([
+      this.semanticSearch(query, limit * 2, filters, minScore),
+      this.keywordSearch(query, limit * 2, filters)
+    ]);
+    const combinedMap = /* @__PURE__ */ new Map();
+    for (const result of semanticResults) {
+      combinedMap.set(result.chunk.id, {
+        ...result,
+        score: result.score * 0.7
+      });
+    }
+    for (const result of keywordResults) {
+      const existing = combinedMap.get(result.chunk.id);
+      if (existing) {
+        existing.score += result.score * 0.3;
+      } else {
+        combinedMap.set(result.chunk.id, {
+          ...result,
+          score: result.score * 0.3
+        });
+      }
+    }
+    const combined = Array.from(combinedMap.values()).sort((a, b) => b.score - a.score).slice(0, limit);
+    return combined;
+  }
+  /**
+   * Apply type-based boosting to results
+   */
+  applyTypeBoost(results, typeBoost) {
+    return results.map((result) => {
+      const boost = typeBoost[result.chunk.chunkType] ?? 1;
+      return {
+        ...result,
+        score: result.score * boost,
+        explanation: result.explanation ? {
+          ...result.explanation,
+          intentBoost: boost !== 1,
+          boostReason: boost !== 1 ? `Type boost for ${result.chunk.chunkType}: ${boost}x` : void 0
+        } : void 0
+      };
+    }).sort((a, b) => b.score - a.score);
+  }
+};
+
+// src/engines/discovery.engine.ts
+var DiscoveryEngine = class {
+  gemini;
+  pdfProcessor;
+  logger;
+  sessions = /* @__PURE__ */ new Map();
+  constructor(config, rateLimiter, logger) {
+    this.gemini = new GeminiService(config, rateLimiter, logger);
+    this.pdfProcessor = new PDFProcessor(logger);
+    this.logger = logger;
+  }
+  /**
+   * Analyze a document and generate processing strategy
+   */
+  async discover(options) {
+    const correlationId = generateCorrelationId();
+    this.logger.info("Starting document discovery", { correlationId });
+    const { buffer, metadata } = await this.pdfProcessor.load(options.file);
+    const fileUri = await this.gemini.uploadPdfBuffer(buffer, metadata.filename);
+    const prompt = buildDiscoveryPrompt(options.documentTypeHint);
+    const response = await this.gemini.generateWithPdfUri(fileUri, prompt);
+    let analysisResult;
+    try {
+      let jsonStr = response.text;
+      const jsonMatch = jsonStr.match(/```json\s*([\s\S]*?)\s*```/) || jsonStr.match(/```\s*([\s\S]*?)\s*```/);
+      if (jsonMatch?.[1]) {
+        jsonStr = jsonMatch[1];
+      }
+      analysisResult = JSON.parse(jsonStr);
+      if (!analysisResult.documentType) {
+        throw new Error("Missing documentType in response");
+      }
+      if (!Array.isArray(analysisResult.specialInstructions)) {
+        analysisResult.specialInstructions = this.getDefaultInstructions();
+      }
+    } catch (parseError) {
+      this.logger.warn("Failed to parse discovery response as JSON, using defaults", {
+        error: parseError.message
+      });
+      analysisResult = {
+        documentType: options.documentTypeHint ?? "General",
+        documentTypeName: options.documentTypeHint ?? "General Document",
+        detectedElements: [],
+        specialInstructions: this.getDefaultInstructions(),
+        chunkStrategy: DEFAULT_CHUNK_STRATEGY,
+        confidence: 0.5,
+        reasoning: "Failed to parse AI response, using default configuration"
+      };
+    }
+    const discoveryResult = {
+      id: correlationId,
+      documentType: analysisResult.documentType,
+      documentTypeName: analysisResult.documentTypeName,
+      detectedElements: analysisResult.detectedElements ?? [],
+      specialInstructions: analysisResult.specialInstructions,
+      exampleFormats: analysisResult.exampleFormats,
+      suggestedChunkStrategy: {
+        ...DEFAULT_CHUNK_STRATEGY,
+        ...analysisResult.chunkStrategy
+      },
+      confidence: analysisResult.confidence ?? 0.5,
+      reasoning: analysisResult.reasoning ?? "",
+      pageCount: metadata.pageCount,
+      fileHash: metadata.fileHash,
+      createdAt: /* @__PURE__ */ new Date(),
+      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3)
+      // 24 hours
+    };
+    this.sessions.set(correlationId, {
+      id: correlationId,
+      result: discoveryResult,
+      fileBuffer: buffer,
+      createdAt: /* @__PURE__ */ new Date(),
+      expiresAt: discoveryResult.expiresAt
+    });
+    this.cleanupSessions();
+    this.logger.info("Discovery completed", {
+      correlationId,
+      documentType: discoveryResult.documentType,
+      confidence: discoveryResult.confidence,
+      instructionCount: discoveryResult.specialInstructions.length
+    });
+    return discoveryResult;
+  }
+  /**
+   * Get stored discovery session
+   */
+  getSession(id) {
+    const session = this.sessions.get(id);
+    if (session && session.expiresAt > /* @__PURE__ */ new Date()) {
+      return session;
+    }
+    return void 0;
+  }
+  /**
+   * Remove a session after approval
+   */
+  removeSession(id) {
+    this.sessions.delete(id);
+  }
+  /**
+   * Clean up expired sessions
+   */
+  cleanupSessions() {
+    const now = /* @__PURE__ */ new Date();
+    for (const [id, session] of this.sessions) {
+      if (session.expiresAt <= now) {
+        this.sessions.delete(id);
+      }
+    }
+  }
+  /**
+   * Get default extraction instructions
+   */
+  getDefaultInstructions() {
+    return [
+      "Extract all text content preserving structure",
+      "Convert tables to Markdown table format",
+      "Convert lists to Markdown list format",
+      "Preserve headings with appropriate # levels",
+      "Note any images with [IMAGE: description]",
+      "Maintain the logical flow of content"
+    ];
+  }
+};
+
+// src/context-rag.ts
+var ContextRAG = class {
+  config;
+  logger;
+  rateLimiter;
+  // Engines
+  ingestionEngine;
+  retrievalEngine;
+  discoveryEngine;
+  // Repositories
+  promptConfigRepo;
+  documentRepo;
+  chunkRepo;
+  constructor(userConfig) {
+    const validation = configSchema.safeParse(userConfig);
+    if (!validation.success) {
+      throw new ConfigurationError("Invalid configuration", {
+        errors: validation.error.errors
+      });
+    }
+    this.config = this.resolveConfig(userConfig);
+    this.logger = createLogger(this.config.logging);
+    this.rateLimiter = new RateLimiter(this.config.rateLimitConfig);
+    this.promptConfigRepo = new PromptConfigRepository(this.config.prisma);
+    this.documentRepo = new DocumentRepository(this.config.prisma);
+    this.chunkRepo = new ChunkRepository(this.config.prisma);
+    this.ingestionEngine = new IngestionEngine(this.config, this.rateLimiter, this.logger);
+    this.retrievalEngine = new RetrievalEngine(this.config, this.rateLimiter, this.logger);
+    this.discoveryEngine = new DiscoveryEngine(this.config, this.rateLimiter, this.logger);
+    this.logger.info("Context-RAG initialized", {
+      model: this.config.model,
+      batchConfig: this.config.batchConfig
+    });
+  }
+  /**
+   * Resolve user config with defaults
+   */
+  resolveConfig(userConfig) {
+    return {
+      prisma: userConfig.prisma,
+      geminiApiKey: userConfig.geminiApiKey,
+      model: userConfig.model ?? "gemini-1.5-pro",
+      embeddingModel: userConfig.embeddingModel ?? "text-embedding-004",
+      generationConfig: {
+        ...DEFAULT_GENERATION_CONFIG,
+        ...userConfig.generationConfig
+      },
+      batchConfig: {
+        ...DEFAULT_BATCH_CONFIG,
+        ...userConfig.batchConfig
+      },
+      chunkConfig: {
+        ...DEFAULT_CHUNK_CONFIG,
+        ...userConfig.chunkConfig
+      },
+      rateLimitConfig: {
+        ...DEFAULT_RATE_LIMIT_CONFIG,
+        ...userConfig.rateLimitConfig
+      },
+      logging: {
+        ...DEFAULT_LOG_CONFIG,
+        ...userConfig.logging
+      }
+    };
+  }
+  /**
+   * Get the resolved configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  // ============================================
+  // DISCOVERY METHODS
+  // ============================================
+  /**
+   * Analyze a document and get AI-suggested processing strategy
+   */
+  async discover(options) {
+    return this.discoveryEngine.discover(options);
+  }
+  /**
+   * Approve a discovery strategy and create a prompt config
+   */
+  async approveStrategy(strategyId, overrides) {
+    const session = this.discoveryEngine.getSession(strategyId);
+    if (!session) {
+      throw new NotFoundError("Discovery session", strategyId);
+    }
+    const result = session.result;
+    const systemPrompt = overrides?.systemPrompt ?? result.suggestedPrompt ?? result.specialInstructions.join("\n");
+    const promptConfig = await this.promptConfigRepo.create({
+      documentType: overrides?.documentType ?? result.documentType,
+      name: overrides?.name ?? result.documentTypeName,
+      systemPrompt,
+      chunkStrategy: {
+        ...result.suggestedChunkStrategy,
+        ...overrides?.chunkStrategy
+      },
+      setAsDefault: true,
+      changeLog: overrides?.changeLog ?? `Auto-generated from discovery (confidence: ${result.confidence})`
+    });
+    this.discoveryEngine.removeSession(strategyId);
+    this.logger.info("Strategy approved", {
+      strategyId,
+      promptConfigId: promptConfig.id
+    });
+    return promptConfig;
+  }
+  // ============================================
+  // PROMPT CONFIG METHODS
+  // ============================================
+  /**
+   * Create a custom prompt configuration
+   */
+  async createPromptConfig(config) {
+    return this.promptConfigRepo.create(config);
+  }
+  /**
+   * Get prompt configurations
+   */
+  async getPromptConfigs(filters) {
+    return this.promptConfigRepo.getMany(filters);
+  }
+  /**
+   * Update a prompt configuration (creates new version)
+   */
+  async updatePromptConfig(id, updates) {
+    const existing = await this.promptConfigRepo.getById(id);
+    return this.promptConfigRepo.create({
+      documentType: existing.documentType,
+      name: updates.name ?? existing.name,
+      systemPrompt: updates.systemPrompt ?? existing.systemPrompt,
+      chunkStrategy: {
+        ...existing.chunkStrategy,
+        ...updates.chunkStrategy
+      },
+      setAsDefault: true,
+      changeLog: updates.changeLog ?? `Updated from version ${existing.version}`
+    });
+  }
+  /**
+   * Activate a specific prompt config version
+   */
+  async activatePromptConfig(id) {
+    return this.promptConfigRepo.activate(id);
+  }
+  // ============================================
+  // INGESTION METHODS
+  // ============================================
+  /**
+   * Ingest a document into the RAG system
+   */
+  async ingest(options) {
+    return this.ingestionEngine.ingest(options);
+  }
+  /**
+   * Get the status of a document processing job
+   */
+  async getDocumentStatus(documentId) {
+    return this.documentRepo.getById(documentId);
+  }
+  /**
+   * Retry failed batches for a document
+   */
+  async retryFailedBatches(documentId, _options) {
+    const doc = await this.documentRepo.getById(documentId);
+    throw new Error(
+      `Retry not yet fully implemented. Document ${doc.id} has ${doc.progress.failedBatches} failed batches.`
+    );
+  }
+  // ============================================
+  // SEARCH METHODS
+  // ============================================
+  /**
+   * Search for relevant content
+   */
+  async search(options) {
+    return this.retrievalEngine.search(options);
+  }
+  /**
+   * Search with full metadata response
+   */
+  async searchWithMetadata(options) {
+    return this.retrievalEngine.searchWithMetadata(options);
+  }
+  // ============================================
+  // ADMIN METHODS
+  // ============================================
+  /**
+   * Delete a document and all its chunks
+   */
+  async deleteDocument(documentId) {
+    this.logger.info("Deleting document", { documentId });
+    await this.chunkRepo.deleteByDocumentId(documentId);
+    await this.documentRepo.delete(documentId);
+  }
+  /**
+   * Get system statistics
+   */
+  async getStats() {
+    const stats = await getDatabaseStats(this.config.prisma);
+    return {
+      totalDocuments: stats.documents,
+      totalChunks: stats.chunks,
+      promptConfigs: stats.promptConfigs,
+      storageBytes: stats.totalStorageBytes
+    };
+  }
+  /**
+   * Health check
+   */
+  async healthCheck() {
+    const database = await checkDatabaseConnection(this.config.prisma);
+    let pgvector = false;
+    if (database) {
+      try {
+        pgvector = await checkPgVectorExtension(this.config.prisma);
+      } catch {
+        pgvector = false;
+      }
+    }
+    let status;
+    if (database && pgvector) {
+      status = "healthy";
+    } else if (database) {
+      status = "degraded";
+    } else {
+      status = "unhealthy";
+    }
+    return { status, database, pgvector };
+  }
+};
+
+exports.BatchStatusEnum = BatchStatusEnum;
+exports.ChunkTypeEnum = ChunkTypeEnum;
+exports.ConfigurationError = ConfigurationError;
+exports.ContextRAG = ContextRAG;
+exports.ContextRAGError = ContextRAGError;
+exports.DiscoveryError = DiscoveryError;
+exports.DocumentStatusEnum = DocumentStatusEnum;
+exports.IngestionError = IngestionError;
+exports.SearchError = SearchError;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map