@claude-flow/plugin-legal-contracts 3.0.0-alpha.1

package/dist/mcp-tools.js

@@ -0,0 +1,966 @@
+/**
+ * Legal Contracts Plugin - MCP Tools
+ *
+ * Implements 5 MCP tools for legal contract analysis:
+ * 1. legal/clause-extract - Extract and classify clauses
+ * 2. legal/risk-assess - Identify and score contractual risks
+ * 3. legal/contract-compare - Compare contracts with attention-based alignment
+ * 4. legal/obligation-track - Extract obligations with DAG analysis
+ * 5. legal/playbook-match - Match clauses against negotiation playbook
+ *
+ * Based on ADR-034: Legal Contract Analysis Plugin
+ *
+ * @module v3/plugins/legal-contracts/mcp-tools
+ */
+import { ClauseExtractInputSchema, RiskAssessInputSchema, ContractCompareInputSchema, ObligationTrackInputSchema, PlaybookMatchInputSchema, RiskCategory, } from './types.js';
+import { createAttentionBridge } from './bridges/attention-bridge.js';
+import { createDAGBridge } from './bridges/dag-bridge.js';
+// ============================================================================
+// Clause Extract Tool
+// ============================================================================
+/**
+ * MCP Tool: legal/clause-extract
+ *
+ * Extract and classify clauses from legal documents
+ */
+export const clauseExtractTool = {
+    name: 'legal/clause-extract',
+    description: 'Extract and classify clauses from legal documents',
+    category: 'legal',
+    version: '3.0.0-alpha.1',
+    inputSchema: ClauseExtractInputSchema,
+    handler: async (input, context) => {
+        const startTime = Date.now();
+        try {
+            // Validate input
+            const validated = ClauseExtractInputSchema.parse(input);
+            // Parse document and extract clauses
+            const metadata = parseDocumentMetadata(validated.document);
+            const clauses = await extractClauses(validated.document, validated.clauseTypes, validated.jurisdiction, context);
+            // Separate classified and unclassified
+            const classifiedClauses = clauses.filter(c => c.confidence >= 0.7);
+            const unclassified = clauses
+                .filter(c => c.confidence < 0.7)
+                .map(c => ({
+                text: c.text,
+                startOffset: c.startOffset,
+                endOffset: c.endOffset,
+                reason: `Low confidence: ${(c.confidence * 100).toFixed(1)}%`,
+            }));
+            const result = {
+                success: true,
+                clauses: classifiedClauses,
+                metadata,
+                unclassified,
+                durationMs: Date.now() - startTime,
+            };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                data: result,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: errorMessage,
+                            durationMs: Date.now() - startTime,
+                        }, null, 2),
+                    }],
+            };
+        }
+    },
+};
+// ============================================================================
+// Risk Assess Tool
+// ============================================================================
+/**
+ * MCP Tool: legal/risk-assess
+ *
+ * Assess contractual risks with severity scoring
+ */
+export const riskAssessTool = {
+    name: 'legal/risk-assess',
+    description: 'Assess contractual risks with severity scoring',
+    category: 'legal',
+    version: '3.0.0-alpha.1',
+    inputSchema: RiskAssessInputSchema,
+    handler: async (input, context) => {
+        const startTime = Date.now();
+        try {
+            const validated = RiskAssessInputSchema.parse(input);
+            // Extract clauses first
+            const clauses = await extractClauses(validated.document, undefined, 'US', context);
+            // Assess risks
+            const risks = await assessRisks(clauses, validated.partyRole, validated.riskCategories, validated.industryContext);
+            // Filter by threshold if specified
+            const filteredRisks = validated.threshold
+                ? risks.filter(r => getSeverityLevel(r.severity) >= getSeverityLevel(validated.threshold))
+                : risks;
+            // Build category summary
+            const categorySummary = buildCategorySummary(filteredRisks);
+            // Calculate overall score
+            const overallScore = calculateOverallRiskScore(filteredRisks);
+            const grade = scoreToGrade(overallScore);
+            const result = {
+                success: true,
+                partyRole: validated.partyRole,
+                risks: filteredRisks,
+                categorySummary,
+                overallScore,
+                grade,
+                criticalRisks: filteredRisks
+                    .filter(r => r.severity === 'critical' || r.severity === 'high')
+                    .slice(0, 5),
+                durationMs: Date.now() - startTime,
+            };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                data: result,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: errorMessage,
+                            durationMs: Date.now() - startTime,
+                        }, null, 2),
+                    }],
+            };
+        }
+    },
+};
+// ============================================================================
+// Contract Compare Tool
+// ============================================================================
+/**
+ * MCP Tool: legal/contract-compare
+ *
+ * Compare two contracts with detailed diff and semantic alignment
+ */
+export const contractCompareTool = {
+    name: 'legal/contract-compare',
+    description: 'Compare two contracts with detailed diff and semantic alignment',
+    category: 'legal',
+    version: '3.0.0-alpha.1',
+    inputSchema: ContractCompareInputSchema,
+    handler: async (input, context) => {
+        const startTime = Date.now();
+        try {
+            const validated = ContractCompareInputSchema.parse(input);
+            // Extract clauses from both documents
+            const baseClauses = await extractClauses(validated.baseDocument, undefined, 'US', context);
+            const compareClauses = await extractClauses(validated.compareDocument, undefined, 'US', context);
+            // Initialize attention bridge
+            const attention = context.bridges.attention;
+            if (!attention.isInitialized()) {
+                await attention.initialize();
+            }
+            // Align clauses using attention
+            const alignments = await attention.alignClauses(baseClauses, compareClauses);
+            // Detect changes
+            const changes = detectChanges(baseClauses, compareClauses, alignments);
+            // Calculate similarity score
+            const similarityScore = alignments.length > 0
+                ? alignments.reduce((sum, a) => sum + a.similarity, 0) / alignments.length
+                : 0;
+            // Build summary
+            const summary = {
+                totalChanges: changes.length,
+                added: changes.filter(c => c.type === 'added').length,
+                removed: changes.filter(c => c.type === 'removed').length,
+                modified: changes.filter(c => c.type === 'modified').length,
+                favorable: changes.filter(c => c.impact === 'favorable').length,
+                unfavorable: changes.filter(c => c.impact === 'unfavorable').length,
+            };
+            // Generate redline if requested
+            const redlineMarkup = validated.generateRedline
+                ? generateRedlineMarkup(validated.baseDocument, changes)
+                : undefined;
+            const result = {
+                success: true,
+                mode: validated.comparisonMode,
+                changes,
+                alignments,
+                similarityScore,
+                summary,
+                redlineMarkup,
+                durationMs: Date.now() - startTime,
+            };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                data: result,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: errorMessage,
+                            durationMs: Date.now() - startTime,
+                        }, null, 2),
+                    }],
+            };
+        }
+    },
+};
+// ============================================================================
+// Obligation Track Tool
+// ============================================================================
+/**
+ * MCP Tool: legal/obligation-track
+ *
+ * Extract obligations, deadlines, and dependencies using DAG analysis
+ */
+export const obligationTrackTool = {
+    name: 'legal/obligation-track',
+    description: 'Extract obligations, deadlines, and dependencies using DAG analysis',
+    category: 'legal',
+    version: '3.0.0-alpha.1',
+    inputSchema: ObligationTrackInputSchema,
+    handler: async (input, context) => {
+        const startTime = Date.now();
+        try {
+            const validated = ObligationTrackInputSchema.parse(input);
+            // Extract obligations
+            let obligations = await extractObligations(validated.document, validated.obligationTypes);
+            // Filter by party if specified
+            if (validated.party) {
+                obligations = obligations.filter(o => o.party.toLowerCase().includes(validated.party.toLowerCase()));
+            }
+            // Filter by timeframe if specified
+            if (validated.timeframe) {
+                obligations = filterByTimeframe(obligations, validated.timeframe);
+            }
+            // Initialize DAG bridge
+            const dag = context.bridges.dag;
+            if (!dag.isInitialized()) {
+                await dag.initialize();
+            }
+            // Build dependency graph
+            const graph = await dag.buildDependencyGraph(obligations);
+            // Build timeline
+            const timeline = buildTimeline(obligations);
+            // Find upcoming deadlines (next 30 days)
+            const now = new Date();
+            const thirtyDaysLater = new Date(now.getTime() + 30 * 24 * 60 * 60 * 1000);
+            const upcomingDeadlines = obligations.filter(o => o.dueDate && o.dueDate >= now && o.dueDate <= thirtyDaysLater);
+            // Find overdue
+            const overdue = obligations.filter(o => o.dueDate && o.dueDate < now && o.status !== 'completed' && o.status !== 'waived');
+            const result = {
+                success: true,
+                obligations,
+                graph,
+                timeline,
+                upcomingDeadlines,
+                overdue,
+                durationMs: Date.now() - startTime,
+            };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                data: result,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: errorMessage,
+                            durationMs: Date.now() - startTime,
+                        }, null, 2),
+                    }],
+            };
+        }
+    },
+};
+// ============================================================================
+// Playbook Match Tool
+// ============================================================================
+/**
+ * MCP Tool: legal/playbook-match
+ *
+ * Compare contract clauses against negotiation playbook
+ */
+export const playbookMatchTool = {
+    name: 'legal/playbook-match',
+    description: 'Compare contract clauses against negotiation playbook',
+    category: 'legal',
+    version: '3.0.0-alpha.1',
+    inputSchema: PlaybookMatchInputSchema,
+    handler: async (input, context) => {
+        const startTime = Date.now();
+        try {
+            const validated = PlaybookMatchInputSchema.parse(input);
+            // Parse playbook
+            const playbook = parsePlaybook(validated.playbook);
+            // Extract clauses from document
+            const clauses = await extractClauses(validated.document, undefined, 'US', context);
+            // Initialize attention bridge
+            const attention = context.bridges.attention;
+            if (!attention.isInitialized()) {
+                await attention.initialize();
+            }
+            // Match clauses against playbook
+            const matches = await matchAgainstPlaybook(clauses, playbook, validated.strictness, validated.suggestAlternatives, attention);
+            // Build summary
+            const summary = {
+                totalClauses: matches.length,
+                matchesPreferred: matches.filter(m => m.status === 'matches_preferred').length,
+                matchesAcceptable: matches.filter(m => m.status === 'matches_acceptable').length,
+                requiresFallback: matches.filter(m => m.status === 'requires_fallback').length,
+                violatesRedline: matches.filter(m => m.status === 'violates_redline').length,
+                noMatch: matches.filter(m => m.status === 'no_match').length,
+            };
+            // Find red line violations
+            const redLineViolations = matches.filter(m => m.status === 'violates_redline');
+            // Prioritize negotiations
+            const negotiationPriorities = buildNegotiationPriorities(matches, validated.prioritizeClauses);
+            const result = {
+                success: true,
+                playbook: {
+                    id: playbook.id,
+                    name: playbook.name,
+                    version: playbook.version,
+                },
+                matches,
+                summary,
+                redLineViolations,
+                negotiationPriorities,
+                durationMs: Date.now() - startTime,
+            };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                data: result,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: errorMessage,
+                            durationMs: Date.now() - startTime,
+                        }, null, 2),
+                    }],
+            };
+        }
+    },
+};
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Parse document metadata
+ */
+function parseDocumentMetadata(document) {
+    const hash = simpleHash(document);
+    return {
+        id: `doc-${hash.substring(0, 8)}`,
+        format: 'txt',
+        wordCount: document.split(/\s+/).length,
+        charCount: document.length,
+        language: 'en',
+        parties: [],
+        contentHash: hash,
+    };
+}
+/**
+ * Simple hash function
+ */
+function simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16).padStart(16, '0');
+}
+/**
+ * Extract clauses from document
+ */
+async function extractClauses(document, clauseTypes, _jurisdiction, _context) {
+    const clauses = [];
+    // Define clause patterns
+    const clausePatterns = {
+        indemnification: [/indemnif/i, /hold\s+harmless/i, /defend\s+and\s+indemnify/i],
+        limitation_of_liability: [/limitation\s+of\s+liability/i, /liability\s+shall\s+not\s+exceed/i],
+        termination: [/termination/i, /right\s+to\s+terminate/i, /upon\s+termination/i],
+        confidentiality: [/confidential/i, /non-disclosure/i, /proprietary\s+information/i],
+        ip_assignment: [/intellectual\s+property/i, /assignment\s+of\s+(ip|rights)/i, /work\s+for\s+hire/i],
+        governing_law: [/governing\s+law/i, /governed\s+by\s+the\s+laws/i, /jurisdiction/i],
+        arbitration: [/arbitration/i, /arbitral\s+proceedings/i, /binding\s+arbitration/i],
+        force_majeure: [/force\s+majeure/i, /act\s+of\s+god/i, /beyond\s+reasonable\s+control/i],
+        warranty: [/warrant/i, /represents\s+and\s+warrants/i, /as-is/i],
+        payment_terms: [/payment/i, /invoic/i, /net\s+\d+/i],
+        non_compete: [/non-?compet/i, /not\s+compete/i],
+        non_solicitation: [/non-?solicit/i, /not\s+solicit/i],
+        assignment: [/assignment/i, /may\s+not\s+assign/i],
+        insurance: [/insurance/i, /maintain\s+coverage/i],
+        representations: [/represent/i, /represent\s+and\s+warrant/i],
+        covenants: [/covenant/i, /agrees\s+to/i],
+        data_protection: [/data\s+protection/i, /personal\s+data/i, /gdpr/i, /privacy/i],
+        audit_rights: [/audit/i, /right\s+to\s+inspect/i, /access\s+to\s+records/i],
+    };
+    // Split document into sections/paragraphs
+    const sections = document.split(/\n\n+/);
+    let offset = 0;
+    for (const section of sections) {
+        const sectionStart = document.indexOf(section, offset);
+        const sectionEnd = sectionStart + section.length;
+        offset = sectionEnd;
+        // Try to classify section
+        for (const [type, patterns] of Object.entries(clausePatterns)) {
+            const clauseType = type;
+            // Skip if not in requested types
+            if (clauseTypes && clauseTypes.length > 0 && !clauseTypes.includes(clauseType)) {
+                continue;
+            }
+            // Check patterns
+            let matchCount = 0;
+            for (const pattern of patterns) {
+                if (pattern.test(section)) {
+                    matchCount++;
+                }
+            }
+            if (matchCount > 0) {
+                const confidence = Math.min(0.5 + matchCount * 0.2, 0.99);
+                clauses.push({
+                    id: `clause-${clauses.length + 1}`,
+                    type: clauseType,
+                    text: section.trim(),
+                    startOffset: sectionStart,
+                    endOffset: sectionEnd,
+                    confidence,
+                    keyTerms: extractKeyTerms(section),
+                });
+                break; // Only classify as one type
+            }
+        }
+    }
+    return clauses;
+}
+/**
+ * Extract key terms from text
+ */
+function extractKeyTerms(text) {
+    const terms = [];
+    const termPatterns = [
+        /\$[\d,]+/g, // Dollar amounts
+        /\d+\s*(days?|months?|years?)/gi, // Time periods
+        /\d+%/g, // Percentages
+        /"[^"]+"/g, // Quoted terms
+    ];
+    for (const pattern of termPatterns) {
+        const matches = text.match(pattern);
+        if (matches) {
+            terms.push(...matches);
+        }
+    }
+    return [...new Set(terms)].slice(0, 10);
+}
+/**
+ * Assess risks in clauses
+ */
+async function assessRisks(clauses, _partyRole, categories, _industryContext) {
+    const risks = [];
+    // Risk patterns by clause type and party role
+    const riskPatterns = {
+        indemnification: [
+            {
+                pattern: /unlimited\s+indemnification/i,
+                severity: 'critical',
+                category: 'financial',
+                title: 'Unlimited Indemnification',
+                description: 'Contract requires unlimited indemnification which could expose party to significant financial risk',
+                mitigation: 'Negotiate cap on indemnification liability',
+            },
+        ],
+        limitation_of_liability: [
+            {
+                pattern: /no\s+limitation/i,
+                severity: 'high',
+                category: 'financial',
+                title: 'No Liability Cap',
+                description: 'Contract contains no limitation on liability',
+                mitigation: 'Add liability cap based on contract value or insurance coverage',
+            },
+        ],
+        termination: [
+            {
+                pattern: /immediate\s+termination/i,
+                severity: 'medium',
+                category: 'operational',
+                title: 'Immediate Termination Right',
+                description: 'Counterparty can terminate immediately without notice',
+                mitigation: 'Negotiate notice period for termination',
+            },
+        ],
+        warranty: [
+            {
+                pattern: /as-?is/i,
+                severity: 'medium',
+                category: 'legal',
+                title: 'As-Is Warranty Disclaimer',
+                description: 'Product/service provided without warranty',
+                mitigation: 'Negotiate minimum performance warranties',
+            },
+        ],
+    };
+    for (const clause of clauses) {
+        const patterns = riskPatterns[clause.type] ?? [];
+        for (const riskPattern of patterns) {
+            if (riskPattern.pattern.test(clause.text)) {
+                // Filter by category if specified
+                if (categories && !categories.includes(riskPattern.category)) {
+                    continue;
+                }
+                risks.push({
+                    id: `risk-${risks.length + 1}`,
+                    category: riskPattern.category,
+                    severity: riskPattern.severity,
+                    title: riskPattern.title,
+                    description: riskPattern.description,
+                    clauseIds: [clause.id],
+                    mitigations: [riskPattern.mitigation],
+                    deviatesFromStandard: true,
+                    confidence: clause.confidence,
+                });
+            }
+        }
+    }
+    return risks;
+}
+/**
+ * Get severity level as number
+ */
+function getSeverityLevel(severity) {
+    const levels = {
+        low: 1,
+        medium: 2,
+        high: 3,
+        critical: 4,
+    };
+    return levels[severity];
+}
+/**
+ * Build category summary
+ */
+function buildCategorySummary(risks) {
+    const summary = {};
+    for (const category of Object.values(RiskCategory.options)) {
+        summary[category] = { count: 0, highestSeverity: 'low', totalScore: 0 };
+    }
+    for (const risk of risks) {
+        const cat = summary[risk.category];
+        if (cat) {
+            cat.count++;
+            cat.totalScore += getSeverityLevel(risk.severity);
+            if (getSeverityLevel(risk.severity) > getSeverityLevel(cat.highestSeverity)) {
+                cat.highestSeverity = risk.severity;
+            }
+        }
+    }
+    const result = {};
+    for (const [category, data] of Object.entries(summary)) {
+        result[category] = {
+            count: data.count,
+            highestSeverity: data.highestSeverity,
+            averageScore: data.count > 0 ? data.totalScore / data.count : 0,
+        };
+    }
+    return result;
+}
+/**
+ * Calculate overall risk score
+ */
+function calculateOverallRiskScore(risks) {
+    if (risks.length === 0)
+        return 100;
+    const maxScore = 100;
+    let penalty = 0;
+    for (const risk of risks) {
+        const severityPenalty = {
+            low: 2,
+            medium: 5,
+            high: 15,
+            critical: 30,
+        };
+        penalty += severityPenalty[risk.severity];
+    }
+    return Math.max(0, maxScore - penalty);
+}
+/**
+ * Convert score to grade
+ */
+function scoreToGrade(score) {
+    if (score >= 90)
+        return 'A';
+    if (score >= 80)
+        return 'B';
+    if (score >= 70)
+        return 'C';
+    if (score >= 60)
+        return 'D';
+    return 'F';
+}
+/**
+ * Detect changes between documents
+ */
+function detectChanges(baseClauses, compareClauses, alignments) {
+    const changes = [];
+    const alignedCompare = new Set(alignments.map(a => a.compareClauseId));
+    for (const alignment of alignments) {
+        const baseClause = baseClauses.find(c => c.id === alignment.baseClauseId);
+        const compareClause = compareClauses.find(c => c.id === alignment.compareClauseId);
+        if (alignment.alignmentType === 'no_match') {
+            changes.push({
+                type: 'removed',
+                clauseType: baseClause?.type,
+                baseSection: baseClause?.section,
+                baseText: baseClause?.text,
+                significance: 0.8,
+                impact: 'requires_review',
+                explanation: 'Clause exists in base but not in comparison document',
+            });
+        }
+        else if (alignment.alignmentType !== 'exact') {
+            changes.push({
+                type: 'modified',
+                clauseType: baseClause?.type,
+                baseSection: baseClause?.section,
+                compareSection: compareClause?.section,
+                baseText: baseClause?.text,
+                compareText: compareClause?.text,
+                significance: 1 - alignment.similarity,
+                impact: 'requires_review',
+                explanation: `Clause modified (${(alignment.similarity * 100).toFixed(1)}% similarity)`,
+            });
+        }
+    }
+    // Find added clauses
+    for (const clause of compareClauses) {
+        if (!alignedCompare.has(clause.id)) {
+            changes.push({
+                type: 'added',
+                clauseType: clause.type,
+                compareSection: clause.section,
+                compareText: clause.text,
+                significance: 0.7,
+                impact: 'requires_review',
+                explanation: 'New clause in comparison document',
+            });
+        }
+    }
+    return changes;
+}
+/**
+ * Generate redline markup
+ */
+function generateRedlineMarkup(baseDocument, changes) {
+    // Simplified redline generation
+    let markup = baseDocument;
+    for (const change of changes) {
+        if (change.type === 'removed' && change.baseText) {
+            markup = markup.replace(change.baseText, `<del style="color:red">${change.baseText}</del>`);
+        }
+        else if (change.type === 'added' && change.compareText) {
+            markup += `\n<ins style="color:green">${change.compareText}</ins>`;
+        }
+    }
+    return markup;
+}
+/**
+ * Extract obligations from document
+ */
+async function extractObligations(document, types) {
+    const obligations = [];
+    // Obligation patterns
+    const obligationPatterns = {
+        payment: [
+            { pattern: /shall\s+pay/i, type: 'payment' },
+            { pattern: /payment\s+due/i, type: 'payment' },
+        ],
+        delivery: [
+            { pattern: /shall\s+deliver/i, type: 'delivery' },
+            { pattern: /delivery\s+date/i, type: 'delivery' },
+        ],
+        notification: [
+            { pattern: /shall\s+notify/i, type: 'notification' },
+            { pattern: /provide\s+notice/i, type: 'notification' },
+        ],
+        approval: [
+            { pattern: /shall\s+approve/i, type: 'approval' },
+            { pattern: /written\s+approval/i, type: 'approval' },
+        ],
+        compliance: [
+            { pattern: /shall\s+comply/i, type: 'compliance' },
+            { pattern: /in\s+compliance\s+with/i, type: 'compliance' },
+        ],
+    };
+    const sentences = document.split(/[.!?]+/);
+    for (let i = 0; i < sentences.length; i++) {
+        const sentence = sentences[i]?.trim() ?? '';
+        if (!sentence)
+            continue;
+        for (const [, patterns] of Object.entries(obligationPatterns)) {
+            for (const { pattern, type } of patterns) {
+                if (types && !types.includes(type))
+                    continue;
+                if (pattern.test(sentence)) {
+                    obligations.push({
+                        id: `obl-${obligations.length + 1}`,
+                        type,
+                        party: extractParty(sentence),
+                        description: sentence,
+                        dependsOn: [],
+                        blocks: [],
+                        clauseIds: [],
+                        status: 'pending',
+                        priority: 'medium',
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    return obligations;
+}
+/**
+ * Extract party from sentence
+ */
+function extractParty(sentence) {
+    const partyPatterns = [
+        /the\s+(buyer|seller|licensor|licensee|employer|employee)/i,
+        /(party\s+a|party\s+b)/i,
+        /the\s+company/i,
+    ];
+    for (const pattern of partyPatterns) {
+        const match = sentence.match(pattern);
+        if (match?.[1]) {
+            return match[1];
+        }
+    }
+    return 'Unknown Party';
+}
+/**
+ * Filter obligations by timeframe
+ */
+function filterByTimeframe(obligations, _timeframe) {
+    // Parse ISO duration or date range
+    // Simplified implementation
+    return obligations;
+}
+/**
+ * Build timeline from obligations
+ */
+function buildTimeline(obligations) {
+    const timeline = new Map();
+    for (const obligation of obligations) {
+        if (obligation.dueDate) {
+            const dateKey = obligation.dueDate.toISOString().split('T')[0] ?? '';
+            const existing = timeline.get(dateKey);
+            if (existing) {
+                existing.obligations.push(obligation.id);
+            }
+            else {
+                timeline.set(dateKey, {
+                    date: obligation.dueDate,
+                    obligations: [obligation.id],
+                    isMilestone: obligation.priority === 'critical',
+                });
+            }
+        }
+    }
+    return Array.from(timeline.values()).sort((a, b) => a.date.getTime() - b.date.getTime());
+}
+/**
+ * Parse playbook from string (JSON or ID)
+ */
+function parsePlaybook(playbookInput) {
+    try {
+        const parsed = JSON.parse(playbookInput);
+        return parsed;
+    }
+    catch {
+        // Return a default playbook
+        return {
+            id: playbookInput,
+            name: 'Default Playbook',
+            contractType: 'General',
+            jurisdiction: 'US',
+            partyRole: 'buyer',
+            updatedAt: new Date(),
+            version: '1.0.0',
+            positions: [],
+        };
+    }
+}
+/**
+ * Match clauses against playbook
+ */
+async function matchAgainstPlaybook(clauses, playbook, strictness, suggestAlternatives, _attention) {
+    const matches = [];
+    for (const clause of clauses) {
+        const position = playbook.positions.find(p => p.clauseType === clause.type);
+        if (!position) {
+            matches.push({
+                clauseId: clause.id,
+                position: {
+                    clauseType: clause.type,
+                    preferredLanguage: '',
+                    acceptableVariations: [],
+                    redLines: [],
+                    fallbackPositions: [],
+                    negotiationNotes: '',
+                    businessJustification: '',
+                },
+                status: 'no_match',
+                preferredSimilarity: 0,
+                recommendation: 'No playbook position defined for this clause type',
+            });
+            continue;
+        }
+        // Check against preferred language
+        const preferredSimilarity = calculateTextSimilarity(clause.text, position.preferredLanguage);
+        // Determine status based on similarity and strictness
+        let status;
+        const thresholds = {
+            strict: { preferred: 0.95, acceptable: 0.9, fallback: 0.8 },
+            moderate: { preferred: 0.85, acceptable: 0.75, fallback: 0.6 },
+            flexible: { preferred: 0.7, acceptable: 0.6, fallback: 0.4 },
+        };
+        const threshold = thresholds[strictness];
+        // Check red lines first
+        const violatesRedLine = position.redLines.some(rl => clause.text.toLowerCase().includes(rl.toLowerCase()));
+        if (violatesRedLine) {
+            status = 'violates_redline';
+        }
+        else if (preferredSimilarity >= threshold.preferred) {
+            status = 'matches_preferred';
+        }
+        else if (position.acceptableVariations.some(v => calculateTextSimilarity(clause.text, v) >= threshold.acceptable)) {
+            status = 'matches_acceptable';
+        }
+        else if (position.fallbackPositions.length > 0) {
+            status = 'requires_fallback';
+        }
+        else {
+            status = 'no_match';
+        }
+        matches.push({
+            clauseId: clause.id,
+            position,
+            status,
+            preferredSimilarity,
+            suggestedAlternative: suggestAlternatives ? position.preferredLanguage : undefined,
+            recommendation: generateRecommendation(status, clause.type),
+        });
+    }
+    return matches;
+}
+/**
+ * Calculate text similarity (simplified)
+ */
+function calculateTextSimilarity(text1, text2) {
+    if (!text1 || !text2)
+        return 0;
+    const words1 = new Set(text1.toLowerCase().split(/\s+/));
+    const words2 = new Set(text2.toLowerCase().split(/\s+/));
+    const intersection = new Set([...words1].filter(w => words2.has(w)));
+    const union = new Set([...words1, ...words2]);
+    return intersection.size / union.size;
+}
+/**
+ * Generate recommendation based on match status
+ */
+function generateRecommendation(status, _clauseType) {
+    const recommendations = {
+        matches_preferred: 'Clause matches preferred playbook position. No action required.',
+        matches_acceptable: 'Clause is within acceptable variation. Consider negotiating closer to preferred position.',
+        requires_fallback: 'Clause requires fallback position. Review fallback options and negotiate accordingly.',
+        violates_redline: 'CRITICAL: Clause violates red line. This must be negotiated before signing.',
+        no_match: 'No playbook position available. Conduct independent review of this clause.',
+    };
+    return recommendations[status];
+}
+/**
+ * Build negotiation priorities
+ */
+function buildNegotiationPriorities(matches, prioritizedTypes) {
+    const priorities = [];
+    const statusPriority = {
+        violates_redline: 100,
+        requires_fallback: 70,
+        no_match: 50,
+        matches_acceptable: 30,
+        matches_preferred: 10,
+    };
+    for (const match of matches) {
+        let priority = statusPriority[match.status];
+        // Boost priority for prioritized clause types
+        if (prioritizedTypes?.includes(match.position.clauseType)) {
+            priority += 20;
+        }
+        priorities.push({
+            clauseId: match.clauseId,
+            priority,
+            reason: match.recommendation,
+        });
+    }
+    return priorities.sort((a, b) => b.priority - a.priority);
+}
+// ============================================================================
+// Tool Registry
+// ============================================================================
+/**
+ * All Legal Contracts MCP Tools
+ */
+export const legalContractsTools = [
+    clauseExtractTool,
+    riskAssessTool,
+    contractCompareTool,
+    obligationTrackTool,
+    playbookMatchTool,
+];
+/**
+ * Tool name to handler map
+ */
+export const toolHandlers = new Map([
+    ['legal/clause-extract', clauseExtractTool.handler],
+    ['legal/risk-assess', riskAssessTool.handler],
+    ['legal/contract-compare', contractCompareTool.handler],
+    ['legal/obligation-track', obligationTrackTool.handler],
+    ['legal/playbook-match', playbookMatchTool.handler],
+]);
+/**
+ * Create tool context with bridges
+ */
+export function createToolContext() {
+    const store = new Map();
+    return {
+        get: (key) => store.get(key),
+        set: (key, value) => { store.set(key, value); },
+        bridges: {
+            attention: createAttentionBridge(),
+            dag: createDAGBridge(),
+        },
+    };
+}
+export default legalContractsTools;
+//# sourceMappingURL=mcp-tools.js.map