mcp-sequential-research 1.0.0

package/dist/compilers.js

@@ -0,0 +1,871 @@
+/**
+ * Research Report Compilation
+ *
+ * Deterministic compiler that transforms research plan + raw results
+ * into a structured markdown report with citations.
+ */
+import { generateId, isoNow, formatSourcesList, countWords, deduplicateCitations, renumberCitations, applyCitationMapping, formatBulletList, formatCallout, } from "./format.js";
+/**
+ * Section templates by query type
+ */
+const SECTION_TEMPLATES = {
+    definition: {
+        heading: "Overview",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (data.definition) {
+                parts.push(String(data.definition));
+                if (citations.length > 0) {
+                    parts[parts.length - 1] += ` ${formatInlineCitations(citations)}`;
+                }
+            }
+            if (Array.isArray(data.characteristics) && data.characteristics.length > 0) {
+                parts.push("\n**Key Characteristics:**");
+                parts.push(formatBulletList(data.characteristics.map(String)));
+            }
+            if (Array.isArray(data.examples) && data.examples.length > 0) {
+                parts.push("\n**Examples:**");
+                parts.push(formatBulletList(data.examples.map(String)));
+            }
+            return parts.join("\n");
+        },
+    },
+    comparison: {
+        heading: "Comparison",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (Array.isArray(data.similarities) && data.similarities.length > 0) {
+                parts.push("**Similarities:**");
+                parts.push(formatBulletList(data.similarities.map(String)));
+            }
+            if (Array.isArray(data.differences) && data.differences.length > 0) {
+                parts.push("\n**Differences:**");
+                parts.push(formatBulletList(data.differences.map(String)));
+            }
+            if (data.recommendation) {
+                parts.push(`\n**Recommendation:** ${data.recommendation}`);
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    enumeration: {
+        heading: "Types and Categories",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (Array.isArray(data.items) && data.items.length > 0) {
+                parts.push(formatBulletList(data.items.map(String)));
+            }
+            if (data.categories && typeof data.categories === "object") {
+                for (const [category, items] of Object.entries(data.categories)) {
+                    parts.push(`\n**${category}:**`);
+                    if (Array.isArray(items)) {
+                        parts.push(formatBulletList(items.map(String)));
+                    }
+                }
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    procedure: {
+        heading: "Process",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (Array.isArray(data.prerequisites) && data.prerequisites.length > 0) {
+                parts.push("**Prerequisites:**");
+                parts.push(formatBulletList(data.prerequisites.map(String)));
+            }
+            if (Array.isArray(data.steps) && data.steps.length > 0) {
+                parts.push("\n**Steps:**");
+                data.steps.forEach((step, i) => {
+                    parts.push(`${i + 1}. ${step}`);
+                });
+            }
+            if (Array.isArray(data.warnings) && data.warnings.length > 0) {
+                parts.push("\n" + formatCallout(data.warnings.join("\n"), "warning"));
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    causation: {
+        heading: "Causes and Factors",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (Array.isArray(data.primary_causes) && data.primary_causes.length > 0) {
+                parts.push("**Primary Causes:**");
+                parts.push(formatBulletList(data.primary_causes.map(String)));
+            }
+            if (Array.isArray(data.contributing_factors) && data.contributing_factors.length > 0) {
+                parts.push("\n**Contributing Factors:**");
+                parts.push(formatBulletList(data.contributing_factors.map(String)));
+            }
+            if (data.evidence_quality) {
+                parts.push(`\n*Evidence Quality: ${data.evidence_quality}*`);
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    evidence: {
+        heading: "Evidence",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (Array.isArray(data.supporting_evidence) && data.supporting_evidence.length > 0) {
+                parts.push("**Supporting Evidence:**");
+                parts.push(formatBulletList(data.supporting_evidence.map(String)));
+            }
+            if (Array.isArray(data.contrary_evidence) && data.contrary_evidence.length > 0) {
+                parts.push("\n**Contrary Evidence:**");
+                parts.push(formatBulletList(data.contrary_evidence.map(String)));
+            }
+            if (data.consensus) {
+                parts.push(`\n**Consensus:** ${data.consensus}`);
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    current_state: {
+        heading: "Current State",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (data.current_status) {
+                parts.push(String(data.current_status));
+            }
+            if (Array.isArray(data.recent_developments) && data.recent_developments.length > 0) {
+                parts.push("\n**Recent Developments:**");
+                parts.push(formatBulletList(data.recent_developments.map(String)));
+            }
+            if (Array.isArray(data.key_players) && data.key_players.length > 0) {
+                parts.push("\n**Key Players:**");
+                parts.push(formatBulletList(data.key_players.map(String)));
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    historical: {
+        heading: "Historical Context",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (Array.isArray(data.timeline) && data.timeline.length > 0) {
+                parts.push("**Timeline:**");
+                parts.push(formatBulletList(data.timeline.map(String)));
+            }
+            if (Array.isArray(data.milestones) && data.milestones.length > 0) {
+                parts.push("\n**Key Milestones:**");
+                parts.push(formatBulletList(data.milestones.map(String)));
+            }
+            if (Array.isArray(data.key_figures) && data.key_figures.length > 0) {
+                parts.push("\n**Key Figures:**");
+                parts.push(formatBulletList(data.key_figures.map(String)));
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    prediction: {
+        heading: "Future Outlook",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (Array.isArray(data.short_term) && data.short_term.length > 0) {
+                parts.push("**Short-term Outlook:**");
+                parts.push(formatBulletList(data.short_term.map(String)));
+            }
+            if (Array.isArray(data.long_term) && data.long_term.length > 0) {
+                parts.push("\n**Long-term Outlook:**");
+                parts.push(formatBulletList(data.long_term.map(String)));
+            }
+            if (Array.isArray(data.uncertainties) && data.uncertainties.length > 0) {
+                parts.push("\n**Key Uncertainties:**");
+                parts.push(formatBulletList(data.uncertainties.map(String)));
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    opinion: {
+        heading: "Expert Perspectives",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (data.majority_view) {
+                parts.push(`**Majority View:** ${data.majority_view}`);
+            }
+            if (Array.isArray(data.alternative_views) && data.alternative_views.length > 0) {
+                parts.push("\n**Alternative Views:**");
+                parts.push(formatBulletList(data.alternative_views.map(String)));
+            }
+            if (Array.isArray(data.key_debates) && data.key_debates.length > 0) {
+                parts.push("\n**Key Debates:**");
+                parts.push(formatBulletList(data.key_debates.map(String)));
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    // Patent-grade section templates
+    patent_broad: {
+        heading: "Patent Landscape",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (Array.isArray(data.patents) && data.patents.length > 0) {
+                parts.push("**Relevant Patents:**");
+                parts.push(formatBulletList(data.patents.map(String)));
+            }
+            if (Array.isArray(data.key_claims) && data.key_claims.length > 0) {
+                parts.push("\n**Key Claim Language:**");
+                parts.push(formatBulletList(data.key_claims.map(String)));
+            }
+            if (Array.isArray(data.classifications) && data.classifications.length > 0) {
+                parts.push("\n**Technology Classifications:** " + data.classifications.join(", "));
+            }
+            if (Array.isArray(data.assignees) && data.assignees.length > 0) {
+                parts.push("\n**Major Assignees:** " + data.assignees.join(", "));
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    patent_synonyms: {
+        heading: "Terminology Analysis",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (Array.isArray(data.synonyms) && data.synonyms.length > 0) {
+                parts.push("**Alternative Terms:**");
+                parts.push(formatBulletList(data.synonyms.map(String)));
+            }
+            if (Array.isArray(data.patent_language) && data.patent_language.length > 0) {
+                parts.push("\n**Patent Language:**");
+                parts.push(formatBulletList(data.patent_language.map(String)));
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    patent_problem_benefit: {
+        heading: "Problem-Solution Analysis",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (Array.isArray(data.problems) && data.problems.length > 0) {
+                parts.push("**Problems Addressed:**");
+                parts.push(formatBulletList(data.problems.map(String)));
+            }
+            if (Array.isArray(data.benefits) && data.benefits.length > 0) {
+                parts.push("\n**Claimed Benefits:**");
+                parts.push(formatBulletList(data.benefits.map(String)));
+            }
+            if (Array.isArray(data.technical_effects) && data.technical_effects.length > 0) {
+                parts.push("\n**Technical Effects:**");
+                parts.push(formatBulletList(data.technical_effects.map(String)));
+            }
+            if (data.prior_art_gap) {
+                parts.push(`\n**Gap in Prior Art:** ${data.prior_art_gap}`);
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    patent_competitor: {
+        heading: "Competitor Analysis",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (Array.isArray(data.assignees) && data.assignees.length > 0) {
+                parts.push("**Key Patent Holders:**");
+                parts.push(formatBulletList(data.assignees.map(String)));
+            }
+            if (Array.isArray(data.recent_filings) && data.recent_filings.length > 0) {
+                parts.push("\n**Recent Filing Activity:**");
+                parts.push(formatBulletList(data.recent_filings.map(String)));
+            }
+            if (Array.isArray(data.key_patents) && data.key_patents.length > 0) {
+                parts.push("\n**Most Cited Patents:**");
+                parts.push(formatBulletList(data.key_patents.map(String)));
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    patent_limitation: {
+        heading: "Claim Limitations",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (Array.isArray(data.claim_elements) && data.claim_elements.length > 0) {
+                parts.push("**Claim Elements:**");
+                parts.push(formatBulletList(data.claim_elements.map(String)));
+            }
+            if (Array.isArray(data.limitations) && data.limitations.length > 0) {
+                parts.push("\n**Technical Limitations:**");
+                parts.push(formatBulletList(data.limitations.map(String)));
+            }
+            if (data.parameters && typeof data.parameters === "object") {
+                parts.push("\n**Parameter Ranges:**");
+                for (const [param, value] of Object.entries(data.parameters)) {
+                    parts.push(`- ${param}: ${value}`);
+                }
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    // Web query section templates
+    web_academic: {
+        heading: "Academic Research",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (Array.isArray(data.papers) && data.papers.length > 0) {
+                parts.push("**Academic Publications:**");
+                parts.push(formatBulletList(data.papers.map(String)));
+            }
+            if (Array.isArray(data.authors) && data.authors.length > 0) {
+                parts.push("\n**Key Researchers:** " + data.authors.join(", "));
+            }
+            if (Array.isArray(data.institutions) && data.institutions.length > 0) {
+                parts.push("\n**Research Institutions:** " + data.institutions.join(", "));
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    web_vendor: {
+        heading: "Commercial Implementations",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (Array.isArray(data.products) && data.products.length > 0) {
+                parts.push("**Commercial Products:**");
+                parts.push(formatBulletList(data.products.map(String)));
+            }
+            if (Array.isArray(data.vendors) && data.vendors.length > 0) {
+                parts.push("\n**Vendors:** " + data.vendors.join(", "));
+            }
+            if (data.availability) {
+                parts.push(`\n**Market Availability:** ${data.availability}`);
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    web_opensource: {
+        heading: "Open Source Implementations",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (Array.isArray(data.repositories) && data.repositories.length > 0) {
+                parts.push("**Repositories:**");
+                parts.push(formatBulletList(data.repositories.map(String)));
+            }
+            if (Array.isArray(data.implementations) && data.implementations.length > 0) {
+                parts.push("\n**Implementations:**");
+                parts.push(formatBulletList(data.implementations.map(String)));
+            }
+            if (Array.isArray(data.licenses) && data.licenses.length > 0) {
+                parts.push("\n**Licenses:** " + data.licenses.join(", "));
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+    web_conference: {
+        heading: "Conference Papers",
+        level: 2,
+        formatter: (data, citations) => {
+            const parts = [];
+            if (Array.isArray(data.papers) && data.papers.length > 0) {
+                parts.push("**Papers:**");
+                parts.push(formatBulletList(data.papers.map(String)));
+            }
+            if (Array.isArray(data.conferences) && data.conferences.length > 0) {
+                parts.push("\n**Conferences:** " + data.conferences.join(", "));
+            }
+            if (Array.isArray(data.preprints) && data.preprints.length > 0) {
+                parts.push("\n**Preprints:**");
+                parts.push(formatBulletList(data.preprints.map(String)));
+            }
+            if (citations.length > 0) {
+                parts.push(`\n${formatInlineCitations(citations)}`);
+            }
+            return parts.join("\n");
+        },
+    },
+};
+/**
+ * Format inline citation references
+ */
+function formatInlineCitations(citations) {
+    if (citations.length === 0)
+        return "";
+    return citations.map((c) => `[${c.id}]`).join(", ");
+}
+/**
+ * Build a report section from a query result
+ */
+function buildSection(plan, result) {
+    // Find the query in the plan
+    const query = plan.queries.find((q) => q.query_id === result.query_id);
+    if (!query)
+        return null;
+    // Skip failed queries
+    if (!result.success || !result.data)
+        return null;
+    // Get template for query type
+    const template = SECTION_TEMPLATES[query.query_type];
+    if (!template) {
+        // Fallback for unknown types
+        return {
+            heading: query.query_text,
+            level: 2,
+            content: JSON.stringify(result.data, null, 2),
+            citations_used: result.sources?.map((s) => s.id) ?? [],
+        };
+    }
+    const content = template.formatter(result.data, result.sources ?? []);
+    return {
+        heading: template.heading,
+        level: template.level,
+        content,
+        citations_used: result.sources?.map((s) => s.id) ?? [],
+    };
+}
+/**
+ * Generate executive summary from sections
+ */
+function generateExecutiveSummary(topic, sections, stats) {
+    const parts = [];
+    parts.push(`This report presents research findings on **${topic}**.`);
+    if (stats.succeeded > 0) {
+        parts.push(`The analysis covers ${stats.succeeded} research queries across ${sections.length} sections.`);
+    }
+    if (stats.failed > 0) {
+        parts.push(`Note: ${stats.failed} queries could not be completed.`);
+    }
+    // Add brief description of each section
+    const sectionNames = sections.map((s) => s.heading).slice(0, 5);
+    if (sectionNames.length > 0) {
+        parts.push(`Key topics include: ${sectionNames.join(", ")}.`);
+    }
+    return parts.join(" ");
+}
+/**
+ * Build the full markdown report
+ */
+function buildMarkdownReport(title, summary, sections, sources, includeSources, includeMethodology, citationStyle) {
+    const parts = [];
+    // Title
+    parts.push(`# ${title}`);
+    parts.push("");
+    // Executive Summary
+    parts.push("## Executive Summary");
+    parts.push("");
+    parts.push(summary);
+    parts.push("");
+    // Methodology (optional)
+    if (includeMethodology) {
+        parts.push("## Methodology");
+        parts.push("");
+        parts.push("This report was compiled using a sequential research approach:");
+        parts.push("1. Research queries were generated based on the topic and focus areas");
+        parts.push("2. Each query was executed to gather relevant information");
+        parts.push("3. Results were compiled and organized into thematic sections");
+        parts.push("4. Sources were consolidated and citations were verified");
+        parts.push("");
+    }
+    // Content sections
+    for (const section of sections) {
+        parts.push("#".repeat(section.level) + " " + section.heading);
+        parts.push("");
+        parts.push(section.content);
+        parts.push("");
+    }
+    // Sources
+    if (includeSources && sources.length > 0) {
+        parts.push(formatSourcesList(sources, citationStyle));
+    }
+    return parts.join("\n");
+}
+/**
+ * Check if this is a patent-focused research plan
+ */
+function isPatentFocused(plan) {
+    return plan.queries.some((q) => q.query_type.startsWith("patent_") || q.query_type.startsWith("web_"));
+}
+/**
+ * Generate prior art clusters from sources
+ */
+function generatePriorArtClusters(sources, _results, _plan) {
+    const clusters = [];
+    // Group by source type
+    const patentSources = sources.filter((s) => s.source_type === "patent" || s.source_type === "document");
+    const webSources = sources.filter((s) => s.source_type === "web");
+    const academicSources = sources.filter((s) => s.url?.includes(".edu") || s.url?.includes("arxiv") || s.url?.includes("ieee"));
+    if (patentSources.length > 0) {
+        clusters.push({
+            cluster_id: generateId("cluster"),
+            theme: "Patent Prior Art",
+            source_ids: patentSources.map((s) => s.id),
+            relevance: "high",
+            overlap_notes: `${patentSources.length} patent documents identified as potential prior art`,
+        });
+    }
+    if (academicSources.length > 0) {
+        clusters.push({
+            cluster_id: generateId("cluster"),
+            theme: "Academic Publications",
+            source_ids: academicSources.map((s) => s.id),
+            relevance: "medium",
+            overlap_notes: `${academicSources.length} academic sources may establish prior knowledge`,
+        });
+    }
+    const commercialSources = webSources.filter((s) => !s.url?.includes(".edu") && !s.url?.includes("arxiv") && !s.url?.includes("github"));
+    if (commercialSources.length > 0) {
+        clusters.push({
+            cluster_id: generateId("cluster"),
+            theme: "Commercial Prior Art",
+            source_ids: commercialSources.map((s) => s.id),
+            relevance: "medium",
+            overlap_notes: `${commercialSources.length} commercial sources showing market implementation`,
+        });
+    }
+    const ossSources = webSources.filter((s) => s.url?.includes("github") || s.url?.includes("gitlab"));
+    if (ossSources.length > 0) {
+        clusters.push({
+            cluster_id: generateId("cluster"),
+            theme: "Open Source Prior Art",
+            source_ids: ossSources.map((s) => s.id),
+            relevance: "low",
+            overlap_notes: `${ossSources.length} open source implementations may affect novelty`,
+        });
+    }
+    return clusters;
+}
+/**
+ * Generate claim risk flags based on results
+ */
+function generateClaimRiskFlags(sources, results, plan) {
+    const risks = [];
+    // Check for potential anticipation
+    const patentResults = results.filter((r) => {
+        const query = plan.queries.find((q) => q.query_id === r.query_id);
+        return query?.query_type.startsWith("patent_");
+    });
+    if (patentResults.length > 0) {
+        const patentCount = sources.filter((s) => s.source_type === "patent" || s.source_type === "document").length;
+        if (patentCount > 5) {
+            risks.push({
+                risk_id: generateId("risk"),
+                severity: "high",
+                category: "anticipation",
+                description: `${patentCount} potentially relevant patents identified. Review each for anticipation of core claims.`,
+                blocking_sources: sources
+                    .filter((s) => s.source_type === "patent" || s.source_type === "document")
+                    .slice(0, 5)
+                    .map((s) => s.id),
+                mitigation: "Conduct detailed claim-by-claim analysis against top 5 most relevant patents",
+            });
+        }
+    }
+    // Check for obviousness risk
+    const problemBenefitResults = results.filter((r) => {
+        const query = plan.queries.find((q) => q.query_id === r.query_id);
+        return query?.query_type === "patent_problem_benefit";
+    });
+    if (problemBenefitResults.length > 0 && sources.length > 3) {
+        risks.push({
+            risk_id: generateId("risk"),
+            severity: "medium",
+            category: "obviousness",
+            description: "Multiple sources address similar problems. Combination of references may render claims obvious.",
+            mitigation: "Identify unexpected results or synergistic effects to overcome obviousness",
+        });
+    }
+    // Check for academic prior art
+    const academicCount = sources.filter((s) => s.url?.includes(".edu") || s.url?.includes("arxiv") || s.url?.includes("ieee")).length;
+    if (academicCount > 3) {
+        risks.push({
+            risk_id: generateId("risk"),
+            severity: "medium",
+            category: "anticipation",
+            description: `${academicCount} academic publications found. Academic literature often predates patent filings.`,
+            blocking_sources: sources
+                .filter((s) => s.url?.includes(".edu") || s.url?.includes("arxiv"))
+                .slice(0, 3)
+                .map((s) => s.id),
+            mitigation: "Check publication dates against priority date; identify implementation-specific claims",
+        });
+    }
+    return risks;
+}
+/**
+ * Generate novelty gap suggestions
+ */
+function generateNoveltyGaps(sources, results, plan) {
+    const gaps = [];
+    // Look for limitation results
+    const limitationResults = results.filter((r) => {
+        const query = plan.queries.find((q) => q.query_id === r.query_id);
+        return query?.query_type === "patent_limitation";
+    });
+    if (limitationResults.length > 0) {
+        for (const result of limitationResults) {
+            if (!result.success || !result.data)
+                continue;
+            const data = result.data;
+            // Suggest parameter-based differentiation
+            if (data.parameters && typeof data.parameters === "object") {
+                const params = Object.keys(data.parameters);
+                if (params.length > 0) {
+                    gaps.push({
+                        gap_id: generateId("gap"),
+                        limitation_type: "parameter",
+                        description: `Consider novel parameter ranges for: ${params.join(", ")}`,
+                        confidence: "medium",
+                        claim_language_suggestion: `wherein the ${params[0]} is in a range of [X] to [Y]`,
+                    });
+                }
+            }
+            // Suggest structural differentiation
+            if (Array.isArray(data.claim_elements) && data.claim_elements.length > 0) {
+                gaps.push({
+                    gap_id: generateId("gap"),
+                    limitation_type: "structural",
+                    description: "Consider adding structural limitations not found in prior art",
+                    confidence: "medium",
+                    claim_language_suggestion: "comprising a [novel component] configured to [novel function]",
+                });
+            }
+        }
+    }
+    // Look for problem-benefit gaps
+    const problemResults = results.filter((r) => {
+        const query = plan.queries.find((q) => q.query_id === r.query_id);
+        return query?.query_type === "patent_problem_benefit";
+    });
+    if (problemResults.length > 0) {
+        for (const result of problemResults) {
+            if (!result.success || !result.data)
+                continue;
+            const data = result.data;
+            if (data.prior_art_gap) {
+                gaps.push({
+                    gap_id: generateId("gap"),
+                    limitation_type: "functional",
+                    description: String(data.prior_art_gap),
+                    confidence: "high",
+                    claim_language_suggestion: "wherein [component] is configured to [address identified gap]",
+                });
+            }
+        }
+    }
+    // Suggest combination novelty if multiple sources
+    if (sources.length > 5) {
+        gaps.push({
+            gap_id: generateId("gap"),
+            limitation_type: "combination",
+            description: "Consider claiming novel combination of known elements that produces unexpected result",
+            confidence: "low",
+            claim_language_suggestion: "A system comprising [element A] and [element B] configured to cooperatively [produce unexpected result]",
+        });
+    }
+    return gaps;
+}
+/**
+ * Build patent analysis section for markdown report
+ */
+function buildPatentAnalysisSection(clusters, risks, gaps) {
+    const parts = [];
+    if (clusters.length > 0 || risks.length > 0 || gaps.length > 0) {
+        parts.push("## Patent Analysis");
+        parts.push("");
+    }
+    if (clusters.length > 0) {
+        parts.push("### Prior Art Clusters");
+        parts.push("");
+        for (const cluster of clusters) {
+            parts.push(`**${cluster.theme}** (${cluster.relevance} relevance)`);
+            parts.push(`- Sources: ${cluster.source_ids.join(", ")}`);
+            if (cluster.overlap_notes) {
+                parts.push(`- ${cluster.overlap_notes}`);
+            }
+            parts.push("");
+        }
+    }
+    if (risks.length > 0) {
+        parts.push("### Claim Risk Flags");
+        parts.push("");
+        for (const risk of risks) {
+            const severityIcon = risk.severity === "critical" ? "!!!" :
+                risk.severity === "high" ? "!!" : "!";
+            parts.push(`**${severityIcon} ${risk.category.toUpperCase()}** (${risk.severity})`);
+            parts.push(`- ${risk.description}`);
+            if (risk.blocking_sources && risk.blocking_sources.length > 0) {
+                parts.push(`- Blocking sources: ${risk.blocking_sources.join(", ")}`);
+            }
+            if (risk.mitigation) {
+                parts.push(`- Mitigation: ${risk.mitigation}`);
+            }
+            parts.push("");
+        }
+    }
+    if (gaps.length > 0) {
+        parts.push("### Novelty Gap Suggestions");
+        parts.push("");
+        for (const gap of gaps) {
+            parts.push(`**${gap.limitation_type.toUpperCase()}** (${gap.confidence} confidence)`);
+            parts.push(`- ${gap.description}`);
+            if (gap.claim_language_suggestion) {
+                parts.push(`- Suggested claim language: \`${gap.claim_language_suggestion}\``);
+            }
+            parts.push("");
+        }
+    }
+    return parts.join("\n");
+}
+/**
+ * Main compile function
+ */
+export function compileReport(input) {
+    const reportId = generateId("report");
+    const warnings = [];
+    const patentFocused = isPatentFocused(input.plan);
+    // Collect all sources
+    const allSources = [];
+    for (const result of input.raw_results) {
+        if (result.sources) {
+            allSources.push(...result.sources);
+        }
+    }
+    // Deduplicate and optionally renumber
+    const dedupedSources = deduplicateCitations(allSources);
+    const { citations: finalSources, mapping } = renumberCitations(dedupedSources);
+    // Build sections
+    const sections = [];
+    let queriesSucceeded = 0;
+    let queriesFailed = 0;
+    for (const result of input.raw_results) {
+        if (result.success) {
+            queriesSucceeded++;
+            const section = buildSection(input.plan, result);
+            if (section) {
+                // Apply citation renumbering
+                section.content = applyCitationMapping(section.content, mapping);
+                section.citations_used = section.citations_used.map((id) => mapping.get(id) ?? id);
+                sections.push(section);
+            }
+        }
+        else {
+            queriesFailed++;
+            if (result.error) {
+                warnings.push(`Query ${result.query_id} failed: ${result.error}`);
+            }
+        }
+    }
+    // Generate patent analysis if patent-focused
+    let priorArtClusters;
+    let claimRiskFlags;
+    let noveltyGaps;
+    let patentAnalysisSection = "";
+    if (patentFocused) {
+        priorArtClusters = generatePriorArtClusters(finalSources, input.raw_results, input.plan);
+        claimRiskFlags = generateClaimRiskFlags(finalSources, input.raw_results, input.plan);
+        noveltyGaps = generateNoveltyGaps(finalSources, input.raw_results, input.plan);
+        patentAnalysisSection = buildPatentAnalysisSection(priorArtClusters, claimRiskFlags, noveltyGaps);
+    }
+    // Generate title
+    const title = `Research Report: ${input.plan.topic}`;
+    // Generate executive summary
+    const executiveSummary = generateExecutiveSummary(input.plan.topic, sections, { succeeded: queriesSucceeded, failed: queriesFailed });
+    // Build full markdown report
+    let markdownReport = buildMarkdownReport(title, executiveSummary, sections, finalSources, input.include_sources ?? true, input.include_methodology ?? false, input.citation_style ?? "inline");
+    // Append patent analysis section if present
+    if (patentAnalysisSection) {
+        // Insert before sources section
+        const sourcesIndex = markdownReport.lastIndexOf("---\n\n### References");
+        if (sourcesIndex > 0) {
+            markdownReport = markdownReport.slice(0, sourcesIndex) +
+                patentAnalysisSection + "\n" +
+                markdownReport.slice(sourcesIndex);
+        }
+        else {
+            markdownReport += "\n" + patentAnalysisSection;
+        }
+    }
+    // Calculate statistics
+    const wordCount = countWords(markdownReport);
+    const patentSourceCount = finalSources.filter((s) => s.source_type === "patent" || s.source_type === "document").length;
+    const webSourceCount = finalSources.filter((s) => s.source_type === "web").length;
+    return {
+        report_id: reportId,
+        plan_id: input.plan.plan_id,
+        title,
+        compiled_at: isoNow(),
+        executive_summary: executiveSummary,
+        sections,
+        markdown_report: markdownReport,
+        sources: finalSources,
+        statistics: {
+            queries_executed: input.raw_results.length,
+            queries_succeeded: queriesSucceeded,
+            queries_failed: queriesFailed,
+            total_sources: finalSources.length,
+            word_count: wordCount,
+            patent_sources: patentSourceCount > 0 ? patentSourceCount : undefined,
+            web_sources: webSourceCount > 0 ? webSourceCount : undefined,
+        },
+        prior_art_clusters: priorArtClusters && priorArtClusters.length > 0 ? priorArtClusters : undefined,
+        claim_risk_flags: claimRiskFlags && claimRiskFlags.length > 0 ? claimRiskFlags : undefined,
+        novelty_gaps: noveltyGaps && noveltyGaps.length > 0 ? noveltyGaps : undefined,
+        warnings: warnings.length > 0 ? warnings : undefined,
+    };
+}
+//# sourceMappingURL=compilers.js.map