@semanticintent/semantic-chirp-intelligence-mcp 3.1.0 → 4.0.0

package/build/experimental/semantic-intent-parser.js

@@ -1,222 +0,0 @@
-/**
- * Semantic Intent Parser - Proof of Concept
- *
- * Tests the fundamental premise: Can we reliably extract tool configuration
- * from natural language semantic intent?
- *
- * This is a minimal viable test to validate the concept before building
- * the full universal MCP architecture.
- */
-/**
- * Basic semantic intent parser using regex patterns
- */
-export class SemanticIntentParser {
-    static CAPABILITY_MAPPINGS = {
-        'web search': 'web_search',
-        'search': 'web_search',
-        'API calls': 'yahoo_api',
-        'api': 'yahoo_api',
-        'data analysis': 'data_analysis',
-        'analyze': 'data_analysis',
-        'statistical analysis': 'data_analysis',
-        'advice': 'chirp_generation',
-        'recommendations': 'chirp_generation',
-    };
-    /**
-     * Parse semantic intent and extract configuration
-     */
-    parseIntent(intent) {
-        const needsMatch = intent.match(/I need:\s*([^]+?)(?=\nI\s+(?:will|return|estimate)|$)/i);
-        const willMatch = intent.match(/I will:\s*([^]+?)(?=\nI\s+(?:need|return|estimate)|$)/i);
-        const parameters = needsMatch ? this.extractParameters(needsMatch[1]) : [];
-        const capabilities = willMatch ? this.mapCapabilities(willMatch[1]) : [];
-        // Calculate confidence based on what we successfully parsed
-        let confidence = 0.5;
-        if (needsMatch)
-            confidence += 0.25;
-        if (willMatch)
-            confidence += 0.25;
-        return {
-            parameters,
-            capabilities,
-            confidence
-        };
-    }
-    /**
-     * Extract parameter definitions from "I need:" section
-     * Handles patterns like:
-     * - "player name (required string)"
-     * - "date range (optional)"
-     * - "analysis depth (optional enum: basic|detailed)"
-     */
-    extractParameters(needsSection) {
-        const parameters = [];
-        const paramLines = needsSection.split(',').map(line => line.trim());
-        for (const line of paramLines) {
-            const param = this.parseParameterLine(line);
-            if (param) {
-                parameters.push(param);
-            }
-        }
-        return parameters;
-    }
-    /**
-     * Parse a single parameter line
-     */
-    parseParameterLine(line) {
-        // Match patterns like "player name (required string)" or "date (optional)"
-        const match = line.match(/([^(]+)\s*\(([^)]+)\)/);
-        if (!match)
-            return null;
-        const nameRaw = match[1].trim();
-        const specification = match[2].trim().toLowerCase();
-        // Convert "player name" to "player_name"
-        const name = nameRaw.replace(/\s+/g, '_').toLowerCase();
-        // Determine if required
-        const required = specification.includes('required');
-        // Infer type from specification
-        const type = this.inferParameterType(specification);
-        return {
-            name,
-            type,
-            required,
-            description: line.trim()
-        };
-    }
-    /**
-     * Infer parameter type from specification string
-     */
-    inferParameterType(specification) {
-        if (specification.includes('string'))
-            return 'string';
-        if (specification.includes('number'))
-            return 'number';
-        if (specification.includes('boolean'))
-            return 'boolean';
-        if (specification.includes('array'))
-            return 'array';
-        if (specification.includes('object'))
-            return 'object';
-        return 'string'; // Default to string
-    }
-    /**
-     * Map capability descriptions to capability identifiers
-     */
-    mapCapabilities(willSection) {
-        const capabilities = new Set();
-        const text = willSection.toLowerCase();
-        for (const [phrase, capability] of Object.entries(SemanticIntentParser.CAPABILITY_MAPPINGS)) {
-            if (text.includes(phrase.toLowerCase())) {
-                capabilities.add(capability);
-            }
-        }
-        return Array.from(capabilities);
-    }
-}
-/**
- * Test tool definitions for validation
- */
-export const TEST_SEMANTIC_TOOLS = {
-    quickPlayerStats: {
-        name: "test_quick_player_stats",
-        semanticIntent: `
-      Given a player name, I will get their basic stats from Yahoo API.
-
-      I need: player name (required string)
-      I will: API calls
-      I return: goals, assists, points
-      I estimate: simple, 500 tokens
-    `
-    },
-    injuryCheck: {
-        name: "test_injury_check",
-        semanticIntent: `
-      Given a player name, I will search for injury news and check Yahoo status.
-
-      I need: player name (required string), include historical (optional boolean)
-      I will: web search, API calls
-      I return: injury status and timeline
-      I estimate: moderate, 2000 tokens
-    `
-    },
-    tradeAnalysis: {
-        name: "test_trade_analysis",
-        semanticIntent: `
-      Given player names, I will analyze stats and provide trade recommendation.
-
-      I need: your players (required array), their players (required array)
-      I will: API calls, data analysis, recommendations
-      I return: trade verdict with confidence score
-      I estimate: complex, 5000 tokens
-    `
-    }
-};
-/**
- * Validation function to test parser accuracy
- */
-export function validateParser() {
-    const parser = new SemanticIntentParser();
-    const results = [];
-    // Test 1: Quick Player Stats
-    const test1 = parser.parseIntent(TEST_SEMANTIC_TOOLS.quickPlayerStats.semanticIntent);
-    const expected1 = {
-        parameters: [{ name: 'player_name', type: 'string', required: true }],
-        capabilities: ['yahoo_api']
-    };
-    const match1 = test1.parameters.length === 1 &&
-        test1.parameters[0].name === 'player_name' &&
-        test1.parameters[0].required === true &&
-        test1.capabilities.includes('yahoo_api');
-    results.push({
-        tool: 'quickPlayerStats',
-        parsed: test1,
-        expected: expected1,
-        match: match1
-    });
-    // Test 2: Injury Check
-    const test2 = parser.parseIntent(TEST_SEMANTIC_TOOLS.injuryCheck.semanticIntent);
-    const expected2 = {
-        parameters: [
-            { name: 'player_name', type: 'string', required: true },
-            { name: 'include_historical', type: 'boolean', required: false }
-        ],
-        capabilities: ['web_search', 'yahoo_api']
-    };
-    const match2 = test2.parameters.length === 2 &&
-        test2.parameters[0].name === 'player_name' &&
-        test2.parameters[1].name === 'include_historical' &&
-        test2.parameters[1].type === 'boolean' &&
-        test2.capabilities.includes('web_search') &&
-        test2.capabilities.includes('yahoo_api');
-    results.push({
-        tool: 'injuryCheck',
-        parsed: test2,
-        expected: expected2,
-        match: match2
-    });
-    // Test 3: Trade Analysis
-    const test3 = parser.parseIntent(TEST_SEMANTIC_TOOLS.tradeAnalysis.semanticIntent);
-    const expected3 = {
-        parameters: [
-            { name: 'your_players', type: 'array', required: true },
-            { name: 'their_players', type: 'array', required: true }
-        ],
-        capabilities: ['yahoo_api', 'data_analysis', 'chirp_generation']
-    };
-    const match3 = test3.parameters.length === 2 &&
-        test3.parameters[0].name === 'your_players' &&
-        test3.parameters[0].type === 'array' &&
-        test3.capabilities.includes('yahoo_api') &&
-        test3.capabilities.includes('data_analysis');
-    results.push({
-        tool: 'tradeAnalysis',
-        parsed: test3,
-        expected: expected3,
-        match: match3
-    });
-    const allMatch = results.every(r => r.match);
-    return {
-        success: allMatch,
-        results
-    };
-}

package/build/experimental/semantic-tool-integration.js

@@ -1,146 +0,0 @@
-/**
- * Semantic Tool Integration - Live Test
- *
- * Adds a semantic intent-driven tool to the existing MCP server
- * for end-to-end validation without disrupting working tools.
- */
-import { SemanticIntentParser } from './semantic-intent-parser.js';
-/**
- * Semantic test tool definition
- */
-export const SEMANTIC_PLAYER_COMPARISON = {
-    name: "semantic_player_comparison",
-    description: "EXPERIMENTAL: Compare two players using semantic intent parsing",
-    semanticIntent: `
-    Given two player names, I will get their current season stats from Yahoo API
-    and return a simple comparison of goals, assists, points, and plus/minus.
-
-    I need: player1 (required string), player2 (required string)
-    I will: API calls, data analysis
-    I return: side-by-side player comparison
-    I estimate: simple analysis, 1000 tokens
-  `
-};
-/**
- * Parse semantic intent and return configuration
- */
-export function parsePlayerComparisonIntent() {
-    const parser = new SemanticIntentParser();
-    return parser.parseIntent(SEMANTIC_PLAYER_COMPARISON.semanticIntent);
-}
-/**
- * Helper to get parsed input schema for MCP tool registration
- */
-export function getPlayerComparisonInputSchema() {
-    const parsed = parsePlayerComparisonIntent();
-    // Convert parsed parameters to MCP input schema
-    const properties = {};
-    const required = [];
-    for (const param of parsed.parameters) {
-        properties[param.name] = {
-            type: param.type,
-            description: param.description
-        };
-        if (param.required) {
-            required.push(param.name);
-        }
-    }
-    return {
-        type: "object",
-        properties,
-        required
-    };
-}
-/**
- * Execute the semantic tool with player comparison logic
- */
-export async function executePlayerComparison(args, getPlayerStatsFunc, searchPlayersFunc) {
-    const parsed = parsePlayerComparisonIntent();
-    // Validate required parameters based on parsed intent
-    if (!args.player1 || !args.player2) {
-        throw new Error(`Missing required parameters: ${parsed.parameters.filter(p => p.required).map(p => p.name).join(', ')}`);
-    }
-    try {
-        // Step 1: Search for players across multiple position groups for better coverage
-        // Yahoo API limits results per query, so we search across positions and combine
-        const positions = ['C', 'LW', 'RW', 'D', 'G', undefined]; // undefined = all positions
-        const searchPromises = positions.map(pos => searchPlayersFunc(pos, 100));
-        const allSearchResults = await Promise.all(searchPromises);
-        // Combine all players from different searches
-        const allPlayers = [];
-        for (const result of allSearchResults) {
-            if (result.players) {
-                allPlayers.push(...result.players);
-            }
-        }
-        // Remove duplicates based on player_id
-        const uniquePlayers = Array.from(new Map(allPlayers.map((p) => [p.player_id, p])).values());
-        // Find matching players by name (case-insensitive, flexible matching)
-        const findPlayer = (playerName) => {
-            const searchName = playerName.toLowerCase().trim();
-            return uniquePlayers.find((p) => {
-                const playerFullName = (p.name || '').toLowerCase();
-                // Match if either name contains the other, or exact match
-                return playerFullName.includes(searchName) ||
-                    searchName.includes(playerFullName) ||
-                    playerFullName === searchName;
-            });
-        };
-        const player1Match = findPlayer(args.player1);
-        const player2Match = findPlayer(args.player2);
-        if (!player1Match) {
-            throw new Error(`Could not find player: ${args.player1}. Searched ${uniquePlayers.length} unique players across ${allSearchResults.length} position groups.`);
-        }
-        if (!player2Match) {
-            throw new Error(`Could not find player: ${args.player2}. Searched ${uniquePlayers.length} unique players across ${allSearchResults.length} position groups.`);
-        }
-        // Step 2: Get detailed stats for both players
-        const [player1Stats, player2Stats] = await Promise.all([
-            getPlayerStatsFunc(player1Match.player_id),
-            getPlayerStatsFunc(player2Match.player_id)
-        ]);
-        // Step 3: Format comparison
-        const comparison = {
-            player1: {
-                name: player1Stats.name,
-                team: player1Stats.team,
-                position: player1Stats.position,
-                stats: {
-                    goals: player1Stats.stats.goals || 0,
-                    assists: player1Stats.stats.assists || 0,
-                    points: player1Stats.stats.points || 0,
-                    plus_minus: player1Stats.stats.plus_minus || 0
-                }
-            },
-            player2: {
-                name: player2Stats.name,
-                team: player2Stats.team,
-                position: player2Stats.position,
-                stats: {
-                    goals: player2Stats.stats.goals || 0,
-                    assists: player2Stats.stats.assists || 0,
-                    points: player2Stats.stats.points || 0,
-                    plus_minus: player2Stats.stats.plus_minus || 0
-                }
-            },
-            winner: {
-                goals: player1Stats.stats.goals > player2Stats.stats.goals ? player1Stats.name : player2Stats.name,
-                assists: player1Stats.stats.assists > player2Stats.stats.assists ? player1Stats.name : player2Stats.name,
-                points: player1Stats.stats.points > player2Stats.stats.points ? player1Stats.name : player2Stats.name,
-                plus_minus: player1Stats.stats.plus_minus > player2Stats.stats.plus_minus ? player1Stats.name : player2Stats.name
-            },
-            _debug: {
-                semanticIntentParsing: {
-                    parsedParameters: parsed.parameters,
-                    parsedCapabilities: parsed.capabilities,
-                    parseConfidence: `${(parsed.confidence * 100).toFixed(0)}%`,
-                    message: "✅ Tool configuration auto-generated from semantic intent!"
-                }
-            }
-        };
-        return comparison;
-    }
-    catch (error) {
-        throw new Error(`Player comparison failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}

package/build/experimental/test-parser.js

@@ -1,61 +0,0 @@
-/**
- * Test script for semantic intent parser
- * Run this to validate the POC works
- */
-import { SemanticIntentParser, validateParser, TEST_SEMANTIC_TOOLS } from './semantic-intent-parser.js';
-console.log('='.repeat(80));
-console.log('SEMANTIC INTENT PARSER - PROOF OF CONCEPT TEST');
-console.log('='.repeat(80));
-console.log();
-// Test individual tool parsing
-console.log('📝 Testing individual tool parsing:\n');
-const parser = new SemanticIntentParser();
-for (const [key, tool] of Object.entries(TEST_SEMANTIC_TOOLS)) {
-    console.log(`\n🔧 Tool: ${tool.name}`);
-    console.log('─'.repeat(80));
-    console.log('Intent:');
-    console.log(tool.semanticIntent.trim());
-    console.log();
-    const parsed = parser.parseIntent(tool.semanticIntent);
-    console.log('Parsed Configuration:');
-    console.log('  Parameters:', JSON.stringify(parsed.parameters, null, 4));
-    console.log('  Capabilities:', parsed.capabilities);
-    console.log('  Confidence:', `${(parsed.confidence * 100).toFixed(0)}%`);
-}
-console.log('\n' + '='.repeat(80));
-console.log('🧪 VALIDATION TEST RESULTS');
-console.log('='.repeat(80));
-console.log();
-// Run comprehensive validation
-const validation = validateParser();
-for (const result of validation.results) {
-    const icon = result.match ? '✅' : '❌';
-    console.log(`${icon} ${result.tool}: ${result.match ? 'PASS' : 'FAIL'}`);
-    if (!result.match) {
-        console.log('   Expected:', JSON.stringify(result.expected, null, 2));
-        console.log('   Got:', JSON.stringify(result.parsed, null, 2));
-    }
-}
-console.log();
-console.log('─'.repeat(80));
-console.log(`Overall Result: ${validation.success ? '✅ ALL TESTS PASSED' : '❌ SOME TESTS FAILED'}`);
-console.log('─'.repeat(80));
-console.log('\n📊 ANALYSIS:\n');
-if (validation.success) {
-    console.log('✅ The semantic intent parser successfully extracted:');
-    console.log('   • Parameter names, types, and required/optional flags');
-    console.log('   • Capability requirements from action descriptions');
-    console.log('   • Confidence scores based on parse completeness');
-    console.log();
-    console.log('🎯 RECOMMENDATION: The foundation is solid!');
-    console.log('   The basic premise works - semantic intent can reliably generate tool configuration.');
-    console.log('   You can proceed with confidence to build the full universal architecture.');
-}
-else {
-    console.log('⚠️  The parser had issues extracting configuration correctly.');
-    console.log('   Review the failed tests above to understand parsing limitations.');
-    console.log('   The regex patterns may need refinement, or the concept needs rethinking.');
-}
-console.log('\n' + '='.repeat(80));
-// Exit with appropriate code
-process.exit(validation.success ? 0 : 1);