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

package/scripts/smoke.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * 💨 Smoke test — call every registered tool over stdio and classify the result.
+ *
+ * Distinguishes three outcomes:
+ *   ✅ returned data      — worked
+ *   🟡 clean error        — failed, but reported it properly
+ *   💥 crash-like         — leaked a TypeError / undefined access to the client
+ *
+ * The point is the third category. A tool that throws a raw TypeError at an MCP
+ * client during a live draft is unusable; one that says "Yahoo returned 403" is
+ * merely blocked. Run this whenever Yahoo is unreachable — an outage is the
+ * cheapest way to exercise every failure path at once.
+ *
+ *   npm run smoke
+ */
+
+import { spawn } from 'child_process';
+
+const TOOLS = [
+  ['set_roster', { roster_text: 'C\tAuston Matthews\tTOR - C\nD\tCale Makar\tCOL - D\nG\tIgor Shesterkin\tNYR - G\nLW\tKirill Kaprizov\tMIN - LW', team_name: 'Smoke Team' }],
+  ['set_opponent_roster', { roster_text: 'Connor McDavid\nNathan MacKinnon\nQuinn Hughes', team_name: 'Smoke Opponent' }],
+  ['set_standings', { standings_text: '1. Smoke Team 8-2-1 142 pts\n2. Smoke Opponent 7-3-1 138 pts' }],
+  ['show_stored_data', {}],
+  ['get_team_roster', {}],
+  ['get_league_standings', {}],
+  ['search_players', { position: 'C', count: 5 }],
+  ['get_player_stats', { player_id: 'Cale Makar' }],
+  ['compare_matchup', {}],
+  ['optimize_lineup', {}],
+  ['get_streaming_recommendations', {}],
+  ['get_games_in_hand', {}],
+  ['get_roster_transaction_recommendations', {}],
+  ['ice', {}],
+  ['governance_dashboard', {}],
+  ['analyze_breakout_players', { max_results: 5 }],
+  ['analyze_weekend_streams', { date_range: { start: '2026-10-09', end: '2026-10-11' } }],
+  ['chirp_opponent', {}],
+  ['analyze_trade', { giving: ['Cale Makar'], receiving: ['Quinn Hughes'] }],
+  ['schedule_value', { teams: ['TOR', 'SEA'], playoff_start_week: 22, playoff_end_week: 24 }],
+  ['chirp_draft_pick', { pick_number: 5, max_results: 5 }],
+];
+
+const proc = spawn(process.execPath, ['build/index.js'], { stdio: ['pipe', 'pipe', 'pipe'] });
+
+let buf = '';
+const results = new Map();
+proc.stdout.on('data', d => {
+  buf += d;
+  let i;
+  while ((i = buf.indexOf('\n')) >= 0) {
+    const line = buf.slice(0, i); buf = buf.slice(i + 1);
+    if (!line.trim()) continue;
+    try {
+      const m = JSON.parse(line);
+      if (typeof m.id === 'number' && m.id >= 100) results.set(m.id, m);
+    } catch {}
+  }
+});
+
+const send = o => proc.stdin.write(JSON.stringify(o) + '\n');
+send({ jsonrpc:'2.0', id:1, method:'initialize', params:{ protocolVersion:'2024-11-05', capabilities:{}, clientInfo:{name:'t',version:'1'} } });
+send({ jsonrpc:'2.0', method:'notifications/initialized' });
+await new Promise(r => setTimeout(r, 1500));
+
+for (let i = 0; i < TOOLS.length; i++) {
+  const [name, args] = TOOLS[i];
+  send({ jsonrpc:'2.0', id:100+i, method:'tools/call', params:{ name, arguments: args } });
+  // The first four establish the league state everything else reads.
+  if (i < 4) { const t0=Date.now(); while (!results.has(100+i) && Date.now()-t0 < 30000) await new Promise(r=>setTimeout(r,150)); }
+}
+await new Promise(r => setTimeout(r, 40000));
+
+console.log('\nTool behaviour (v4 — no account, NHL public data only):\n');
+let crashed = 0, degraded = 0, worked = 0, missing = 0;
+TOOLS.forEach(([name], i) => {
+  const m = results.get(100 + i);
+  if (!m) { console.log(`  ⏳ ${name.padEnd(40)} NO RESPONSE`); missing++; return; }
+  const text = m.result?.content?.[0]?.text ?? JSON.stringify(m.error ?? {});
+  const isErr = m.result?.isError === true || Boolean(m.error);
+  const has403 = /403|not authorized/i.test(text);
+  const crashLike = /TypeError|undefined is not|Cannot read|is not a function/i.test(text);
+  if (crashLike) { console.log(`  💥 ${name.padEnd(40)} CRASH-LIKE: ${text.slice(0,90).replace(/\n/g,' ')}`); crashed++; }
+  else if (has403 || isErr) { console.log(`  🟡 ${name.padEnd(40)} clean error`); degraded++; }
+  else { console.log(`  ✅ ${name.padEnd(40)} returned data`); worked++; }
+});
+console.log(`\n  ✅ ${worked} worked   🟡 ${degraded} degraded cleanly   💥 ${crashed} crash-like   ⏳ ${missing} no response`);
+proc.kill();
+
+// Only a crash-like response or a missing one is a failure. A clean error is
+// the correct behaviour when the upstream API is unavailable.
+process.exit(crashed > 0 || missing > 0 ? 1 : 0);

package/.env.example

@@ -1,8 +0,0 @@
-# Get these from https://developer.yahoo.com/apps/create/
-YAHOO_CLIENT_ID=your_client_id_here
-YAHOO_CLIENT_SECRET=your_client_secret_here
-
-# Your league and team IDs, from your team URL:
-# https://hockey.fantasysports.yahoo.com/hockey/{LEAGUE_ID}/{TEAM_ID}
-YAHOO_LEAGUE_ID=your_league_id_here
-YAHOO_TEAM_ID=your_team_id_here

package/authenticate.js

@@ -1,207 +0,0 @@
-// OAuth Helper Script for Yahoo Fantasy
-// Run this ONCE to get your access token
-// Usage: node authenticate.js
-
-import * as fs from 'fs';
-import * as dotenv from 'dotenv';
-import * as https from 'https';
-import * as url from 'url';
-import selfsigned from 'selfsigned';
-
-dotenv.config();
-
-const CLIENT_ID = process.env.YAHOO_CLIENT_ID;
-const CLIENT_SECRET = process.env.YAHOO_CLIENT_SECRET;
-const REDIRECT_URI = 'https://localhost:3000/callback';
-const TOKEN_FILE = '.yahoo-oauth.json';
-
-if (!CLIENT_ID || !CLIENT_SECRET) {
-  console.error('❌ Missing YAHOO_CLIENT_ID or YAHOO_CLIENT_SECRET in .env');
-  console.error('📝 Please create a .env file with your Yahoo API credentials');
-  console.error('   Get them from: https://developer.yahoo.com/apps/create/');
-  process.exit(1);
-}
-
-// Generate self-signed certificate for local HTTPS
-console.log('🔐 Generating self-signed certificate for HTTPS...');
-const attrs = [{ name: 'commonName', value: 'localhost' }];
-const pems = selfsigned.generate(attrs, {
-  keySize: 2048,
-  days: 365,
-  algorithm: 'sha256',
-  extensions: [
-    {
-      name: 'subjectAltName',
-      altNames: [
-        { type: 2, value: 'localhost' },
-        { type: 7, ip: '127.0.0.1' }
-      ]
-    }
-  ]
-});
-
-console.log('🔐 Starting Yahoo OAuth flow...\n');
-
-// HTTPS server options with self-signed certificate
-const serverOptions = {
-  key: pems.private,
-  cert: pems.cert,
-};
-
-// Create an HTTPS server to handle the callback
-const server = https.createServer(serverOptions, async (req, res) => {
-  const parsedUrl = url.parse(req.url, true);
-
-  if (parsedUrl.pathname === '/') {
-    // Build Yahoo OAuth authorization URL
-    const authUrl = `https://api.login.yahoo.com/oauth2/request_auth?client_id=${CLIENT_ID}&redirect_uri=${encodeURIComponent(REDIRECT_URI)}&response_type=code&language=en-us`;
-
-    res.writeHead(302, { 'Location': authUrl });
-    res.end();
-    console.log('🔐 Redirecting to Yahoo for authorization...');
-    return;
-  }
-
-  if (parsedUrl.pathname === '/callback') {
-    const authCode = parsedUrl.query.code;
-
-    if (!authCode) {
-      res.writeHead(400, { 'Content-Type': 'text/html' });
-      res.end('<h1>❌ Error: No authorization code received</h1>');
-      setTimeout(() => {
-        server.close();
-        process.exit(1);
-      }, 1000);
-      return;
-    }
-
-    try {
-      console.log('📝 Exchanging authorization code for access token...');
-
-      // Exchange the code for a token
-      const tokenResponse = await fetch('https://api.login.yahoo.com/oauth2/get_token', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/x-www-form-urlencoded',
-          'Authorization': 'Basic ' + Buffer.from(`${CLIENT_ID}:${CLIENT_SECRET}`).toString('base64')
-        },
-        body: new URLSearchParams({
-          grant_type: 'authorization_code',
-          redirect_uri: REDIRECT_URI,
-          code: authCode
-        })
-      });
-
-      if (!tokenResponse.ok) {
-        throw new Error(`Token exchange failed: ${tokenResponse.status} ${tokenResponse.statusText}`);
-      }
-
-      const token = await tokenResponse.json();
-      console.log('📝 Token retrieved successfully');
-
-      // Save the token with timestamp
-      const tokenWithTimestamp = {
-        access_token: token.access_token,
-        refresh_token: token.refresh_token,
-        expires_in: token.expires_in,
-        token_type: token.token_type,
-        xoauth_yahoo_guid: token.xoauth_yahoo_guid,
-        timestamp: Date.now(),
-      };
-
-      fs.writeFileSync(TOKEN_FILE, JSON.stringify(tokenWithTimestamp, null, 2));
-      console.log(`✅ Token saved to ${TOKEN_FILE}`);
-
-      // Success page
-      res.writeHead(200, { 'Content-Type': 'text/html' });
-      res.end(`
-        <html>
-          <head>
-            <title>🏒 Authentication Successful - ICE Activated</title>
-            <style>
-              body {
-                font-family: Arial, sans-serif;
-                padding: 50px;
-                text-align: center;
-                background: linear-gradient(135deg, #0891b2 0%, #06b6d4 100%);
-                color: white;
-              }
-              .container {
-                background: white;
-                color: #333;
-                padding: 40px;
-                border-radius: 10px;
-                max-width: 500px;
-                margin: 0 auto;
-                box-shadow: 0 10px 40px rgba(0,0,0,0.2);
-              }
-              h1 { color: #0891b2; }
-              .emoji { font-size: 48px; margin: 20px 0; }
-              code {
-                background: #f5f5f5;
-                padding: 2px 6px;
-                border-radius: 3px;
-                color: #0891b2;
-              }
-            </style>
-          </head>
-          <body>
-            <div class="container">
-              <div class="emoji">🏒✅❄️</div>
-              <h1>ICE Activated!</h1>
-              <p>Yahoo authentication successful. Intent Chirp Engine is ready to dominate.</p>
-              <p>You can close this window and return to your terminal.</p>
-              <hr>
-              <p><strong>Next steps:</strong></p>
-              <ol style="text-align: left; display: inline-block;">
-                <li>Server is built and ready</li>
-                <li>Test with: <code>npm start</code></li>
-                <li>Add to Claude Desktop config</li>
-                <li>Start getting chirped with winning insights</li>
-              </ol>
-            </div>
-          </body>
-        </html>
-      `);
-
-      // Close server after success
-      setTimeout(() => {
-        server.close();
-        console.log('\n🏒 ICE is ready! Next steps:');
-        console.log('   1. Test the server: npm start');
-        console.log('   2. Add to Claude Desktop config (see ACTIVATION_STEPS.md)');
-        console.log('   3. Start dominating your fantasy league with semantic chirps');
-        process.exit(0);
-      }, 1000);
-    } catch (error) {
-      console.error('❌ Error during callback:', error);
-      res.writeHead(500, { 'Content-Type': 'text/html' });
-      res.end(`
-        <html>
-          <head><title>Authentication Failed</title></head>
-          <body style="font-family: Arial; padding: 50px; text-align: center;">
-            <h1 style="color: #f44336;">❌ Authentication Failed</h1>
-            <p>Check the terminal for error details.</p>
-          </body>
-        </html>
-      `);
-      setTimeout(() => {
-        server.close();
-        process.exit(1);
-      }, 1000);
-    }
-  }
-});
-
-server.listen(3000, () => {
-  console.log('🌐 HTTPS Server started on https://localhost:3000');
-  console.log('\n👉 Open this URL in your browser to start authentication:');
-  console.log('   https://localhost:3000/\n');
-  console.log('⏳ Waiting for authentication...\n');
-
-  // Helpful reminders
-  console.log('💡 Make sure your Yahoo app has this redirect URI configured:');
-  console.log('   https://localhost:3000/callback\n');
-  console.log('⚠️  Your browser will show a security warning (self-signed cert)');
-  console.log('   Click "Advanced" → "Proceed to localhost" to continue\n');
-});

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

@@ -1,188 +0,0 @@
-/**
- * Semantic Breakout Tool Integration
- *
- * Implements breakout player analysis using semantic intent pattern.
- * This tool uses natural language intent to auto-configure the MCP tool.
- */
-import { SemanticIntentParser } from './semantic-intent-parser.js';
-/**
- * Semantic tool definition for breakout player analysis
- *
- * This comprehensive prompt integrates:
- * - Data-driven predictability (40% recent, 30% projections, 20% opportunity, 10% risk)
- * - External source references (Rotowire, NHL EDGE, DobberHockey)
- * - Position-specific filtering
- * - League context awareness
- */
-export const SEMANTIC_BREAKOUT_ANALYSIS = {
-    name: "analyze_breakout_players",
-    description: "Analyze free agents to identify top pickups and breakout candidates using comprehensive data-driven scoring",
-    semanticIntent: `
-    I analyze free agents in Yahoo Fantasy Hockey to recommend top 5-10 pickups and 3-5 breakout candidates.
-    I use a predictable scoring formula: 40% recent performance + 30% projections + 20% opportunity - 10% risk.
-    I focus on players under 50% owned and provide position-specific analysis.
-
-    I need: position filter (optional array of strings like ["C", "RW"]),
-            ownership threshold (optional number, default 50),
-            breakout age max (optional number, default 26),
-            minimum score (optional number, default 0),
-            max results (optional number, default 10),
-            chirp intensity (optional string),
-            personality mode (optional string),
-            enable chirp (optional boolean)
-
-    I will: Yahoo API calls, statistical analysis, trend detection, opportunity scoring, risk assessment
-
-    I return: Top pickups with scores, breakout candidates, position breakdown, market intelligence
-
-    I estimate: moderate complexity, 3000 tokens
-  `
-};
-/**
- * Parse semantic intent for breakout analysis
- */
-export function parseBreakoutAnalysisIntent() {
-    const parser = new SemanticIntentParser();
-    return parser.parseIntent(SEMANTIC_BREAKOUT_ANALYSIS.semanticIntent);
-}
-/**
- * Get MCP input schema from semantic intent
- */
-export function getBreakoutAnalysisInputSchema() {
-    const parsed = parseBreakoutAnalysisIntent();
-    // Build schema from parsed parameters
-    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);
-        }
-    }
-    // Add enum constraints for specific parameters
-    if (properties.chirp_intensity) {
-        properties.chirp_intensity.enum = ['gentle', 'standard', 'savage', 'ice_cold'];
-    }
-    if (properties.personality_mode) {
-        properties.personality_mode.enum = ['analytical', 'motivational', 'roast_master', 'championship_coach'];
-    }
-    if (properties.position_filter) {
-        properties.position_filter.items = { type: 'string' };
-    }
-    return {
-        type: "object",
-        properties,
-        required: required.length > 0 ? required : undefined
-    };
-}
-/**
- * Execute breakout analysis with semantic configuration
- */
-export async function executeBreakoutAnalysis(args, breakoutAnalysis) {
-    const parsed = parseBreakoutAnalysisIntent();
-    // Build semantic contract
-    const semanticContract = {
-        chirp_intensity: args.chirp_intensity || 'standard',
-        personality_mode: args.personality_mode || 'analytical',
-        enable_chirp: args.enable_chirp !== false,
-        semantic_intent: 'user_requested',
-        tool_context: 'analyze_breakout_players'
-    };
-    // Build analysis args
-    const analysisArgs = {
-        position_filter: args.position_filter,
-        ownership_threshold: args.ownership_threshold,
-        breakout_age_max: args.breakout_age_max,
-        min_score: args.min_score,
-        max_results: args.max_results
-    };
-    try {
-        // Execute analysis using template pattern
-        const result = await breakoutAnalysis.executeAnalysis(analysisArgs, semanticContract);
-        // Enhance with semantic metadata
-        return {
-            ...result,
-            _semantic_metadata: {
-                tool_name: SEMANTIC_BREAKOUT_ANALYSIS.name,
-                parsed_capabilities: parsed.capabilities,
-                parse_confidence: `${(parsed.confidence * 100).toFixed(0)}%`,
-                message: '✅ Tool auto-configured from semantic intent!',
-                prompt_integration: {
-                    scoring_formula: '40% recent + 30% projections + 20% opportunity - 10% risk',
-                    external_sources: 'Ready for: Rotowire, NHL EDGE, DobberHockey integration',
-                    data_driven: 'Predictable rankings with confidence scores'
-                }
-            }
-        };
-    }
-    catch (error) {
-        throw new Error(`Breakout analysis failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Improved prompt recommendations for Claude Desktop integration
- */
-export const BREAKOUT_PROMPT_IMPROVEMENTS = {
-    semantic_clarity: {
-        original: "Complex multi-paragraph template with embedded formulas",
-        improved: "Structured semantic intent with clear I need/I will/I return sections",
-        benefit: "Claude Desktop can better understand tool purpose and auto-suggest when user asks about breakouts"
-    },
-    parameter_discovery: {
-        original: "Parameters embedded in prose",
-        improved: "Explicit parameter definitions with types and optionality",
-        benefit: "MCP can auto-generate input schema, reducing manual configuration"
-    },
-    capability_mapping: {
-        original: "References to external sources without integration plan",
-        improved: "Capability tags (yahoo_api, data_analysis) that map to available functions",
-        benefit: "Tool knows what it can and cannot do, preventing hallucination"
-    },
-    predictability_enhancement: {
-        original: "Scoring formula mentioned in prose",
-        improved: "Formula implemented in code with observable weights",
-        benefit: "Consistent, repeatable results that users can trust"
-    },
-    integration_points: {
-        yahoo_api: "Direct integration via YahooApiClient",
-        rotowire: "Placeholder for future web scraping capability",
-        nhl_edge: "Placeholder for NHL API integration",
-        dobber_hockey: "Placeholder for prospect data integration"
-    },
-    usage_with_claude_desktop: `
-When user asks: "tell me about breakout players" or "who should I pick up?"
-
-Claude Desktop will:
-1. Recognize semantic intent matches analyze_breakout_players tool
-2. Auto-extract parameters from conversation context (league format, roster needs)
-3. Call tool with appropriate chirp settings (analytical by default)
-4. Present results in conversational format with player tables and reasoning
-
-Example interaction:
-User: "I need a right wing, who are the best breakout candidates?"
-
-Claude: *uses analyze_breakout_players with position_filter=["RW"]*
-
-        "Based on data-driven analysis, here are the top RW breakout candidates:
-
-        🏒 Must-Adds (Score 80+):
-        1. [Player Name] (Team) - 85 score
-           - Catalyst: Top-6 center opportunity
-           - Recent: 0.9 PPG | Projected: 0.7 FPG
-           - Risk: Low (15%)
-           - Confidence: High
-
-        2. [Player Name] (Team) - 82 score
-           ...
-
-        📊 Position Analysis:
-        - RW pool strength: 15 candidates with 65+ scores
-        - Market trend: RW pickups trending up 23%
-        - Recommendation: Act fast on must-adds
-
-        💡 Next steps: Should I analyze your roster to see who you could drop?"
-  `
-};