docorbit 0.1.0 → 0.1.1

package/packages/retrieval/src/engine.ts

@@ -1,120 +0,0 @@
-import type {
-  SearchResult,
-  SearchOptions,
-  ContextPackage,
-  ContextOptions,
-  ScoringWeights,
-  SourceAuthority,
-} from '../../shared/src/index.ts';
-import { DocOrbitRepository } from '../../storage/src/index.ts';
-import { resolveScoringWeights } from './weights.ts';
-import { detectQueryIntent } from './intent.ts';
-import { scoreChunkCandidate } from './scorer.ts';
-import { packContext } from './packer.ts';
-import { resolveProjectContext } from '../../workspace/src/index.ts';
-
-export class RetrievalEngine {
-  private repository: DocOrbitRepository;
-  private defaultWeights: ScoringWeights;
-
-  constructor(repository: DocOrbitRepository, defaultWeights?: Partial<ScoringWeights>) {
-    this.repository = repository;
-    this.defaultWeights = resolveScoringWeights(defaultWeights);
-  }
-
-  /**
-   * Deterministic hybrid search combining FTS5 lexical matching, exact phrases,
-   * title/breadcrumb boosts, shallow symbol matches, intent weighting, and authority.
-   */
-  async search(query: string, options: SearchOptions = {}): Promise<SearchResult[]> {
-    const intent = options.intent || detectQueryIntent(query);
-    const weights = resolveScoringWeights(options.weights || this.defaultWeights);
-    const limit = options.limit || 10;
-
-    let targetDocVersion = options.docVersion;
-
-    if (options.projectDir) {
-      const projContext = resolveProjectContext(options.projectDir, query, this.repository);
-      if (projContext.matchedDependency && !targetDocVersion) {
-        targetDocVersion = projContext.matchedDependency.targetDocVersion;
-      }
-    }
-
-    // Fetch candidate pool from FTS5 with extra headroom for re-ranking
-    const candidates = this.repository.searchChunksFts(query, {
-      limit: Math.max(limit * 3, 30),
-      snapshotId: options.snapshotId,
-      chunkType: options.chunkType,
-    });
-
-    if (candidates.length === 0) {
-      return [];
-    }
-
-    const scoredResults: SearchResult[] = [];
-
-    // Cache source authority per page
-    const pageAuthorityCache = new Map<string, SourceAuthority>();
-
-    for (const item of candidates) {
-      let authority: SourceAuthority = 'official';
-      const pageId = item.chunk.pageId;
-
-      if (!pageAuthorityCache.has(pageId)) {
-        const page = this.repository.getPage(pageId);
-        if (page?.sourceId) {
-          const src = this.repository.getSource(page.sourceId);
-          if (src?.authority) {
-            authority = src.authority;
-          }
-        }
-        pageAuthorityCache.set(pageId, authority);
-      } else {
-        authority = pageAuthorityCache.get(pageId)!;
-      }
-
-      const scored = scoreChunkCandidate({
-        chunk: item.chunk,
-        ftsRank: item.ftsRank,
-        symbols: item.symbols,
-        codeSnippets: item.codeSnippets,
-        query,
-        intent,
-        authority,
-        targetDocVersion,
-        weights,
-      });
-
-      if (options.minScore !== undefined && scored.score < options.minScore) {
-        continue;
-      }
-
-      scoredResults.push(scored);
-    }
-
-    // Sort by score descending
-    scoredResults.sort((a, b) => b.score - a.score);
-
-    return scoredResults.slice(0, limit);
-  }
-
-  /**
-   * Assembles a context package tailored for AI coding agents, optimizing for
-   * relevance + coverage - redundancy within a strict token budget.
-   */
-  async buildContext(task: string, options: ContextOptions = {}): Promise<ContextPackage> {
-    const intent = options.intent || detectQueryIntent(task);
-
-    // Retrieve broad candidate set
-    const candidates = await this.search(task, {
-      limit: (options.maxChunks || 15) * 2,
-      snapshotId: options.snapshotId,
-      docVersion: options.docVersion,
-      projectDir: options.projectDir,
-      weights: options.weights,
-      intent,
-    });
-
-    return packContext(task, candidates, intent, options);
-  }
-}

package/packages/retrieval/src/intent.ts

@@ -1,43 +0,0 @@
-import type { QueryIntent } from '../../shared/src/index.ts';
-
-const INTENT_PATTERNS: Array<{ intent: QueryIntent; regex: RegExp }> = [
-  {
-    intent: 'troubleshooting',
-    regex: /\b(error|failed|failure|exception|crash|fix|debug|issue|cannot|unable|why does|broken|invalid|429|401|403|404|500)\b/i,
-  },
-  {
-    intent: 'examples',
-    regex: /\b(example|examples|sample|samples|snippet|snippets|tutorial|how to|quickstart)\b/i,
-  },
-  {
-    intent: 'configuration',
-    regex: /\b(config|configuration|settings|setup|env|\.env|environment|options|flags?|port|credentials|apikey|api_key)\b/i,
-  },
-  {
-    intent: 'api',
-    regex: /\b(api|endpoint|endpoints|parameters?|request|response|headers?|payload|schema|rest|graphql|status code)\b/i,
-  },
-  {
-    intent: 'implementation',
-    regex: /\b(implement|implementation|build|create|integrate|integration|workflow|handler|webhook|callback|oauth|pipeline)\b/i,
-  },
-  {
-    intent: 'conceptual',
-    regex: /\b(architecture|overview|what is|concept|concepts|design|lifecycle|philosophy|background|understand)\b/i,
-  },
-];
-
-
-/**
- * Deterministically detects query intent from task or query text.
- * Falls back to 'conceptual' when no specific pattern matches.
- */
-export function detectQueryIntent(query: string): QueryIntent {
-  const normalized = query.toLowerCase();
-  for (const { intent, regex } of INTENT_PATTERNS) {
-    if (regex.test(normalized)) {
-      return intent;
-    }
-  }
-  return 'conceptual';
-}

package/packages/retrieval/src/packer.ts

@@ -1,145 +0,0 @@
-import type {
-  SearchResult,
-  DocumentChunk,
-  ContextPackage,
-  ContextOptions,
-  QueryIntent,
-} from '../../shared/src/index.ts';
-
-export function packContext(
-  task: string,
-  candidates: SearchResult[],
-  detectedIntent: QueryIntent,
-  options: ContextOptions = {}
-): ContextPackage {
-  const tokenBudget = options.tokenBudget || 3000;
-  const maxChunks = options.maxChunks || 15;
-  const redundancyPenalty = options.redundancyPenalty ?? 0.35;
-
-  const selectedChunks: DocumentChunk[] = [];
-  const selectedChunkIds = new Set<string>();
-  const selectedSectionCounts = new Map<string, number>();
-  const selectedPages = new Set<string>();
-  const sourcesSet = new Set<string>();
-  const warnings: string[] = [];
-
-  let totalEstimatedTokens = 0;
-  const remainingCandidates = [...candidates];
-
-  while (remainingCandidates.length > 0 && selectedChunks.length < maxChunks) {
-    let bestIdx = -1;
-    let bestUtility = -Infinity;
-
-    for (let i = 0; i < remainingCandidates.length; i++) {
-      const candidate = remainingCandidates[i];
-      const chunk = candidate.chunk;
-
-      // Check if it strictly fits within the remaining token budget
-      if (totalEstimatedTokens + chunk.tokenEstimate > tokenBudget) {
-        continue;
-      }
-
-
-      const sectionKey = `${chunk.pageId}:${chunk.sectionPath.join(' > ')}`;
-      const sectionOverlap = selectedSectionCounts.get(sectionKey) || 0;
-
-      // Penalize multiple chunks from the exact same section to encourage diversity/coverage
-      const redundancyFactor = Math.pow(1 - redundancyPenalty, sectionOverlap);
-
-      // Reward discovering new pages / sections (coverage bonus)
-      const coverageMultiplier = selectedPages.has(chunk.pageId) ? 1.0 : 1.25;
-
-      const utility = candidate.score * redundancyFactor * coverageMultiplier;
-
-      if (utility > bestUtility) {
-        bestUtility = utility;
-        bestIdx = i;
-      }
-    }
-
-    if (bestIdx === -1) {
-      // No remaining candidate fits within the remaining token budget
-      break;
-    }
-
-    const chosen = remainingCandidates.splice(bestIdx, 1)[0];
-    const chunk = chosen.chunk;
-
-    selectedChunks.push(chunk);
-    selectedChunkIds.add(chunk.id);
-
-    const sectionKey = `${chunk.pageId}:${chunk.sectionPath.join(' > ')}`;
-    selectedSectionCounts.set(sectionKey, (selectedSectionCounts.get(sectionKey) || 0) + 1);
-    selectedPages.add(chunk.pageId);
-
-    if (chunk.provenance?.targetUrl) {
-      sourcesSet.add(chunk.provenance.targetUrl);
-    } else if (chunk.provenance?.sourceUrl) {
-      sourcesSet.add(chunk.provenance.sourceUrl);
-    }
-
-    totalEstimatedTokens += chunk.tokenEstimate;
-
-    // If chunk is a warning, register it in top-level warnings
-    if (chunk.chunkType === 'warning') {
-      warnings.push(`[${chunk.sectionPath.join(' > ')}]: ${chunk.content.slice(0, 150)}...`);
-    }
-  }
-
-  // Group chunks by page in order of page first appearance in selectedChunks (most relevant page first)
-  const pageOrder = new Map<string, number>();
-  for (let i = 0; i < selectedChunks.length; i++) {
-    const pId = selectedChunks[i].pageId;
-    if (!pageOrder.has(pId)) {
-      pageOrder.set(pId, pageOrder.size);
-    }
-  }
-
-  const sortedChunks = [...selectedChunks].sort((a, b) => {
-    const pOrderA = pageOrder.get(a.pageId) ?? 0;
-    const pOrderB = pageOrder.get(b.pageId) ?? 0;
-    if (pOrderA !== pOrderB) return pOrderA - pOrderB;
-    return a.ordinal - b.ordinal;
-  });
-
-  // Build agent-facing Markdown package
-  const lines: string[] = [];
-  lines.push(`# Context Package: ${task}`);
-  lines.push(`- **Detected Intent**: \`${detectedIntent}\``);
-  lines.push(`- **Estimated Tokens**: ~${totalEstimatedTokens} / ${tokenBudget} tokens (heuristic estimate)`);
-  lines.push(`- **Sources Included**: ${sourcesSet.size > 0 ? Array.from(sourcesSet).map(s => `[${s}](${s})`).join(', ') : 'Local documentation'}`);
-
-  if (warnings.length > 0) {
-    lines.push('\n> [!WARNING]');
-    lines.push('> **Relevant Advisories & Caveats**:');
-    for (const w of warnings) {
-      lines.push(`> - ${w}`);
-    }
-  }
-
-  lines.push('\n---\n');
-
-  for (const chunk of sortedChunks) {
-    const breadcrumb = chunk.sectionPath.length > 0 ? chunk.sectionPath.join(' > ') : (chunk.title || 'General');
-    lines.push(`### ${breadcrumb}`);
-    lines.push(`*Type: \`${chunk.chunkType}\` | Est. Tokens: ~${chunk.tokenEstimate}*`);
-    lines.push('\n' + chunk.content.trim() + '\n');
-    if (chunk.provenance?.sourceUrl) {
-      lines.push(`*Source: ${chunk.provenance.sourceUrl}*\n`);
-    }
-    lines.push('---\n');
-  }
-
-  const markdown = lines.join('\n');
-
-  return {
-    task,
-    detectedIntent,
-    totalEstimatedTokens,
-    tokenBudget,
-    chunks: sortedChunks,
-    markdown,
-    sources: Array.from(sourcesSet),
-    warnings,
-  };
-}

package/packages/retrieval/src/recipe-engine.ts

@@ -1,313 +0,0 @@
-import { createHash } from 'node:crypto';
-import type {
-  Recipe,
-  RecipeStep,
-  RecipeValidationStep,
-  EvidenceLevel,
-  ApiEndpoint,
-  IndexedExample,
-  Pitfall,
-} from '../../shared/src/index.ts';
-import { DocOrbitRepository } from '../../storage/src/index.ts';
-import { RetrievalEngine } from './engine.ts';
-import { resolveProjectContext } from '../../workspace/src/index.ts';
-
-export interface RecipeOptions {
-  docVersion?: string;
-  projectDir?: string;
-}
-
-export class RecipeEngine {
-  private repository: DocOrbitRepository;
-  private retrievalEngine: RetrievalEngine;
-
-  constructor(repository: DocOrbitRepository, retrievalEngine?: RetrievalEngine) {
-    this.repository = repository;
-    this.retrievalEngine = retrievalEngine || new RetrievalEngine(repository);
-  }
-
-  /**
-   * Deterministically compiles an implementation recipe grounded strictly in indexed evidence.
-   * Distinguishes documented facts, inferred relationships, and missing information.
-   * Never invents APIs, steps, prerequisites, or validation steps.
-   */
-  async assembleRecipe(goal: string, options: RecipeOptions = {}): Promise<Recipe> {
-    const cleanGoal = goal.trim();
-    let effectiveDocVersion = options.docVersion;
-
-    // Resolve project and version context if projectDir is provided
-    if (options.projectDir) {
-      const projContext = resolveProjectContext(options.projectDir, cleanGoal, this.repository);
-      if (projContext.matchedDependency && !effectiveDocVersion) {
-        effectiveDocVersion = projContext.matchedDependency.targetDocVersion;
-      }
-    }
-
-    // 1. Query candidate API endpoints, examples, pitfalls, and search chunks
-    const endpoints = this.repository.searchApiEndpoints(cleanGoal, {
-      docVersion: effectiveDocVersion,
-      limit: 10,
-    });
-
-    const examples = this.repository.searchIndexedExamples(cleanGoal, {
-      docVersion: effectiveDocVersion,
-      limit: 10,
-    });
-
-    const pitfalls = this.repository.searchPitfalls(cleanGoal, {
-      docVersion: effectiveDocVersion,
-      limit: 10,
-    });
-
-    const searchResults = await this.retrievalEngine.search(cleanGoal, {
-      docVersion: effectiveDocVersion,
-      limit: 10,
-    });
-
-    // 2. Collect unique source URLs
-    const sourcesSet = new Set<string>();
-    for (const ep of endpoints) {
-      if (ep.provenance?.sourceUrl) sourcesSet.add(ep.provenance.sourceUrl);
-    }
-    for (const ex of examples) {
-      if (ex.sourceUrl) sourcesSet.add(ex.sourceUrl);
-    }
-    for (const pf of pitfalls) {
-      if (pf.provenance?.sourceUrl) sourcesSet.add(pf.provenance.sourceUrl);
-    }
-    for (const sr of searchResults) {
-      if (sr.chunk.provenance?.sourceUrl) sourcesSet.add(sr.chunk.provenance.sourceUrl);
-    }
-    const sources = Array.from(sourcesSet);
-
-    // 3. Assemble Prerequisites strictly from documented requirements
-    const prerequisites: Array<{ text: string; evidenceLevel: EvidenceLevel; sourceUrl?: string }> = [];
-
-    // Check required_config or permission pitfalls
-    for (const pf of pitfalls) {
-      if (pf.kind === 'required_config' || pf.kind === 'permission') {
-        prerequisites.push({
-          text: `${pf.title}: ${pf.content}`,
-          evidenceLevel: 'documented_fact',
-          sourceUrl: pf.provenance?.sourceUrl,
-        });
-      }
-    }
-
-    // Check chunks with prerequisite/setup headings (only relevant chunks with score >= 5.0)
-    for (const sr of searchResults.filter(s => s.score >= 5.0)) {
-      const headingText = (sr.chunk.title || sr.chunk.sectionPath.join(' ')).toLowerCase();
-      if (headingText.includes('prerequisite') || headingText.includes('before you begin') || headingText.includes('requirements')) {
-        const textSnippet = sr.chunk.content.split('\n')[0].trim();
-        if (textSnippet && !prerequisites.some(p => p.text === textSnippet)) {
-          prerequisites.push({
-            text: textSnippet,
-            evidenceLevel: 'documented_fact',
-            sourceUrl: sr.chunk.provenance?.sourceUrl,
-          });
-        }
-      }
-    }
-
-    // 4. Assemble Ordered Steps
-    const orderedSteps: RecipeStep[] = [];
-    const usedApis = new Set<string>();
-    const usedExamples = new Set<string>();
-    const usedPitfalls = new Set<string>();
-    let stepNumber = 1;
-
-    // A. Setup / Client Initialization Step (if documented in examples)
-    const initExample = examples.find(ex =>
-      /(?:new\s+\w+|initialize|config(?:ure)?|createClient|express\(\)|FastAPI\()/i.test(ex.code)
-    );
-    if (initExample) {
-      orderedSteps.push({
-        step: stepNumber++,
-        title: `Initialize Client / Service (${initExample.framework || initExample.language})`,
-        description: `Configure and initialize client instance as documented in ${initExample.task}`,
-        evidenceLevel: 'documented_fact',
-        exampleCode: initExample.code,
-        sourceUrl: initExample.sourceUrl,
-        sourceChunkIds: initExample.chunkId ? [initExample.chunkId] : undefined,
-      });
-      usedExamples.add(initExample.id);
-    }
-
-    // B. Primary API Actions (Documented Fact)
-    for (const ep of endpoints) {
-      const apiStr = `${ep.method.toUpperCase()} ${ep.path}`;
-      if (usedApis.has(apiStr)) continue;
-      usedApis.add(apiStr);
-
-      // Find matching code example for this API
-      const matchingEx = examples.find(ex =>
-        !usedExamples.has(ex.id) &&
-        (ex.relatedApi === apiStr || ex.code.includes(ep.path) || (ep.operationId && ex.code.includes(ep.operationId)))
-      );
-      if (matchingEx) usedExamples.add(matchingEx.id);
-
-      // Find matching pitfalls for this API
-      const matchingPfs = pitfalls.filter(pf =>
-        pf.relatedApi === apiStr ||
-        (ep.deprecated && pf.kind === 'deprecated') ||
-        (pf.kind === 'rate_limit') ||
-        (pf.kind === 'breaking_change')
-      );
-      const stepPitfalls: string[] = [];
-      for (const p of matchingPfs) {
-        const pfStr = `[${p.kind}] ${p.title}: ${p.content}`;
-        stepPitfalls.push(pfStr);
-        usedPitfalls.add(pfStr);
-      }
-
-      // If the endpoint is deprecated, explicitly highlight it in step title/description
-      const depWarning = ep.deprecated ? ' [DEPRECATED]' : '';
-
-      orderedSteps.push({
-        step: stepNumber++,
-        title: `${apiStr}${depWarning}${ep.summary ? ` - ${ep.summary}` : ''}`,
-        description: ep.description || ep.summary || `Execute documented ${apiStr} request with parameters: ${ep.parameters.map(p => `${p.name}${p.required ? ' (required)' : ''}`).join(', ')}`,
-        evidenceLevel: 'documented_fact',
-        apiEndpoint: apiStr,
-        exampleCode: matchingEx?.code,
-        pitfalls: stepPitfalls.length > 0 ? stepPitfalls : undefined,
-        sourceUrl: ep.provenance?.sourceUrl || matchingEx?.sourceUrl,
-        sourceChunkIds: matchingEx?.chunkId ? [matchingEx.chunkId] : undefined,
-      });
-    }
-
-    // C. Remaining Code Examples as implementation steps
-    for (const ex of examples) {
-      if (usedExamples.has(ex.id)) continue;
-      usedExamples.add(ex.id);
-
-      const matchingPfs = pitfalls.filter(pf =>
-        (ex.relatedApi && pf.relatedApi === ex.relatedApi) ||
-        (ex.relatedSymbol && pf.relatedSymbol === ex.relatedSymbol)
-      );
-      const stepPitfalls = matchingPfs.map(p => `[${p.kind}] ${p.title}: ${p.content}`);
-      stepPitfalls.forEach(p => usedPitfalls.add(p));
-
-      orderedSteps.push({
-        step: stepNumber++,
-        title: ex.task,
-        description: `Implement documented code example for ${ex.task} (${ex.language}${ex.framework ? ` / ${ex.framework}` : ''})`,
-        evidenceLevel: 'documented_fact',
-        apiEndpoint: ex.relatedApi,
-        exampleCode: ex.code,
-        pitfalls: stepPitfalls.length > 0 ? stepPitfalls : undefined,
-        sourceUrl: ex.sourceUrl,
-        sourceChunkIds: ex.chunkId ? [ex.chunkId] : undefined,
-      });
-
-      if (ex.relatedApi) usedApis.add(ex.relatedApi);
-    }
-
-    // D. If neither endpoints nor examples existed, check procedural chunks with strong relevance
-    if (orderedSteps.length === 0) {
-      for (const sr of searchResults.filter(s => s.score >= 5.0).slice(0, 3)) {
-        orderedSteps.push({
-          step: stepNumber++,
-          title: sr.chunk.title || sr.chunk.sectionPath.join(' > ') || 'Documented Procedure',
-          description: sr.chunk.content.substring(0, 300),
-          evidenceLevel: 'inferred_relationship',
-          sourceUrl: sr.chunk.provenance?.sourceUrl,
-          sourceChunkIds: [sr.chunk.id],
-        });
-      }
-    }
-
-    // E. If documentation contains no relevant implementation steps, mark missing_information
-    if (orderedSteps.length === 0) {
-      orderedSteps.push({
-        step: stepNumber++,
-        title: 'Missing Implementation Knowledge',
-        description: `The indexed documentation does not contain documented API endpoints, code examples, or procedures for: "${cleanGoal}".`,
-        evidenceLevel: 'missing_information',
-      });
-    }
-
-    // 5. Assemble Evidence-Based Validation Steps
-    const validationSteps: RecipeValidationStep[] = [];
-    let valStepNumber = 1;
-
-    // Validation from API response schemas
-    for (const ep of endpoints) {
-      const okResponse = ep.responseSchema?.['200'] || ep.responseSchema?.['201'];
-      if (okResponse && okResponse.schema) {
-        const props = okResponse.schema.properties ? Object.keys(okResponse.schema.properties) : [];
-        const propsDesc = props.length > 0 ? ` Expected properties: [${props.slice(0, 6).join(', ')}]` : '';
-        const exampleStr = okResponse.example ? JSON.stringify(okResponse.example, null, 2) : undefined;
-
-        validationSteps.push({
-          step: valStepNumber++,
-          description: `Verify ${ep.method.toUpperCase()} ${ep.path} returns HTTP ${okResponse.statusCode}.${propsDesc}`,
-          evidenceLevel: 'documented_fact',
-          expectedResponse: exampleStr || (props.length > 0 ? JSON.stringify(props) : undefined),
-          sourceUrl: ep.provenance?.sourceUrl,
-        });
-      }
-    }
-
-    // Validation from code examples containing verification/assertion patterns
-    for (const ex of examples) {
-      if (/(?:constructEvent|verifySignature|assert|expect|validate|signature)/i.test(ex.code)) {
-        validationSteps.push({
-          step: valStepNumber++,
-          description: `Validate event/data integrity using documented pattern from ${ex.task}`,
-          evidenceLevel: 'documented_fact',
-          testPattern: ex.code,
-          sourceUrl: ex.sourceUrl,
-        });
-      }
-    }
-
-    // If no validation steps can be derived from evidence, do NOT invent any!
-    if (validationSteps.length === 0) {
-      validationSteps.push({
-        step: 1,
-        description: 'No response schemas, test instructions, or verification assertions are documented for this task.',
-        evidenceLevel: 'missing_information',
-      });
-    }
-
-    // Collect all pitfalls
-    for (const pf of pitfalls) {
-      const pfStr = `[${pf.kind}] ${pf.title}: ${pf.content}`;
-      usedPitfalls.add(pfStr);
-    }
-
-    // Calculate confidence score strictly based on evidence
-    let confidence = 0.0;
-    const factSteps = orderedSteps.filter(s => s.evidenceLevel === 'documented_fact').length;
-    const totalSteps = orderedSteps.length;
-
-    if (totalSteps > 0 && factSteps > 0) {
-      confidence += 0.4 * (factSteps / totalSteps);
-      if (endpoints.length > 0) confidence += 0.3;
-      if (examples.length > 0) confidence += 0.2;
-      if (validationSteps.some(v => v.evidenceLevel === 'documented_fact')) confidence += 0.1;
-    }
-
-    confidence = Math.min(1.0, Math.round(confidence * 100) / 100);
-
-    const recipeId = createHash('sha256')
-      .update(`${cleanGoal}:${effectiveDocVersion || 'default'}:${orderedSteps.length}`)
-      .digest('hex')
-      .substring(0, 16);
-
-    return {
-      id: recipeId,
-      goal: cleanGoal,
-      prerequisites,
-      orderedSteps,
-      requiredApis: Array.from(usedApis),
-      examples: Array.from(usedExamples),
-      pitfalls: Array.from(usedPitfalls),
-      validationSteps,
-      sources,
-      docVersion: effectiveDocVersion,
-      confidence,
-    };
-  }
-}