helius-mcp 1.3.0 → 2.0.0

package/dist/scripts/test-solana-knowledge.js

@@ -1,272 +0,0 @@
-/**
- * Integration test for solana-knowledge tools.
- *
- * Run after build:
- *   node dist/scripts/test-solana-knowledge.js
- *
- * Tests each tool against live endpoints and validates the response shape.
- */
-const PASS = '\x1b[32m✅\x1b[0m';
-const FAIL = '\x1b[31m❌\x1b[0m';
-const WARN = '\x1b[33m⚠️\x1b[0m';
-let passed = 0;
-let failed = 0;
-function assert(condition, label, detail) {
-    if (condition) {
-        console.log(`${PASS} ${label}`);
-        passed++;
-    }
-    else {
-        console.log(`${FAIL} ${label}${detail ? ` — ${detail}` : ''}`);
-        failed++;
-    }
-}
-// ---------------------------------------------------------------------------
-// Helpers — minimal reimplementation to test without starting an MCP server
-// ---------------------------------------------------------------------------
-const SIMD_REPO = 'solana-foundation/solana-improvement-documents';
-const SIMD_API_URL = `https://api.github.com/repos/${SIMD_REPO}/contents/proposals`;
-const SIMD_RAW_BASE = `https://raw.githubusercontent.com/${SIMD_REPO}/main/proposals`;
-const UA = 'helius-mcp-test';
-function ghHeaders() {
-    const h = { Accept: 'application/vnd.github.v3+json' };
-    if (process.env.GITHUB_TOKEN)
-        h['Authorization'] = `token ${process.env.GITHUB_TOKEN}`;
-    return h;
-}
-// ---------------------------------------------------------------------------
-// Test: getSIMD
-// ---------------------------------------------------------------------------
-async function testGetSIMD() {
-    console.log('\n--- getSIMD ---');
-    // 1. Fetch SIMD index
-    const indexRes = await fetch(SIMD_API_URL, { headers: { 'User-Agent': UA, ...ghHeaders() } });
-    assert(indexRes.ok, 'SIMD index fetch succeeds', `status=${indexRes.status}`);
-    const files = (await indexRes.json());
-    const mdFiles = files.filter((f) => f.name.endsWith('.md'));
-    assert(mdFiles.length > 50, `SIMD index has >50 proposals (got ${mdFiles.length})`);
-    // 2. Parse filenames
-    const parsed = mdFiles
-        .map((f) => {
-        const match = f.name.match(/^(\d+)-(.+)\.md$/);
-        return match ? { number: match[1], slug: match[2], filename: f.name } : null;
-    })
-        .filter((x) => x !== null);
-    assert(parsed.length === mdFiles.length, `All ${mdFiles.length} filenames parsed correctly`);
-    // 3. Fetch a known SIMD (SIMD-0096)
-    const entry96 = parsed.find((e) => e.number === '0096');
-    assert(!!entry96, 'SIMD-0096 exists in index');
-    if (entry96) {
-        const rawRes = await fetch(`${SIMD_RAW_BASE}/${entry96.filename}`, { headers: { 'User-Agent': UA } });
-        assert(rawRes.ok, 'SIMD-0096 raw fetch succeeds');
-        const content = await rawRes.text();
-        assert(content.length > 500, `SIMD-0096 has substantial content (${content.length} chars)`);
-        assert(content.includes('---'), 'SIMD-0096 has YAML frontmatter delimiter');
-    }
-    // 4. Test number padding logic
-    const padTest = (input, expected) => {
-        const result = input.replace(/^0+/, '').padStart(4, '0');
-        assert(result === expected, `Padding "${input}" → "${result}" (expected "${expected}")`);
-    };
-    padTest('228', '0228');
-    padTest('0096', '0096');
-    padTest('1', '0001');
-    padTest('0001', '0001');
-    // 5. Test not-found with nearby suggestions
-    const entry9999 = parsed.find((e) => e.number === '9999');
-    assert(!entry9999, 'SIMD-9999 does not exist (good — tests not-found path)');
-}
-// ---------------------------------------------------------------------------
-// Test: listSIMDs
-// ---------------------------------------------------------------------------
-async function testListSIMDs() {
-    console.log('\n--- listSIMDs ---');
-    // Already tested via getSIMD index fetch — just verify table format
-    const indexRes = await fetch(SIMD_API_URL, { headers: { 'User-Agent': UA, ...ghHeaders() } });
-    const files = (await indexRes.json());
-    const parsed = files
-        .filter((f) => f.name.endsWith('.md'))
-        .map((f) => {
-        const match = f.name.match(/^(\d+)-(.+)\.md$/);
-        return match ? { number: match[1], slug: match[2] } : null;
-    })
-        .filter(Boolean);
-    const tableRow = `| ${parsed[0].number} | ${parsed[0].slug.replace(/-/g, ' ')} |`;
-    assert(tableRow.includes('|'), 'Table row format is valid markdown');
-    assert(parsed.length > 0, `listSIMDs would return ${parsed.length} entries`);
-}
-// ---------------------------------------------------------------------------
-// Test: readSolanaSourceFile
-// ---------------------------------------------------------------------------
-async function testReadSolanaSourceFile() {
-    console.log('\n--- readSolanaSourceFile ---');
-    // 1. Agave — known file
-    const agaveUrl = 'https://raw.githubusercontent.com/anza-xyz/agave/master/svm/src/lib.rs';
-    const agaveRes = await fetch(agaveUrl, { headers: { 'User-Agent': UA } });
-    assert(agaveRes.ok, `Agave svm/src/lib.rs exists (status=${agaveRes.status})`);
-    const agaveContent = await agaveRes.text();
-    assert(agaveContent.length > 0, `Agave svm/src/lib.rs has content (${agaveContent.length} chars)`);
-    // 2. Firedancer — test with correct default branch ("main")
-    const fdUrl = 'https://raw.githubusercontent.com/firedancer-io/firedancer/main/README.md';
-    const fdRes = await fetch(fdUrl, { headers: { 'User-Agent': UA } });
-    assert(fdRes.ok, `Firedancer README.md on "main" branch exists (status=${fdRes.status})`);
-    // 3. Firedancer — verify default branch is "main" via GitHub API
-    const fdApiRes = await fetch('https://api.github.com/repos/firedancer-io/firedancer', {
-        headers: { 'User-Agent': UA, ...ghHeaders() },
-    });
-    if (fdApiRes.ok) {
-        const fdRepo = (await fdApiRes.json());
-        assert(fdRepo.default_branch === 'main', `Firedancer default branch is "${fdRepo.default_branch}" (expected "main")`);
-    }
-    else {
-        console.log(`${WARN} Could not check Firedancer default branch (status=${fdApiRes.status})`);
-    }
-    // 4. Non-existent file returns error
-    const badUrl = 'https://raw.githubusercontent.com/anza-xyz/agave/master/this/does/not/exist.rs';
-    const badRes = await fetch(badUrl, { headers: { 'User-Agent': UA } });
-    assert(!badRes.ok, `Non-existent path returns error (status=${badRes.status})`);
-    // 5. Truncation logic
-    const longContent = 'x'.repeat(60_000);
-    const MAX_CHARS = 50_000;
-    const truncated = longContent.length > MAX_CHARS;
-    assert(truncated, 'Content >50k chars is detected as needing truncation');
-    const display = longContent.slice(0, MAX_CHARS);
-    assert(display.length === MAX_CHARS, `Truncated to exactly ${MAX_CHARS} chars`);
-}
-// ---------------------------------------------------------------------------
-// Test: searchSolanaDocs
-// ---------------------------------------------------------------------------
-async function testSearchSolanaDocs() {
-    console.log('\n--- searchSolanaDocs ---');
-    // 1. Fetch the docs
-    const docsRes = await fetch('https://solana.com/llms-full.txt', { headers: { 'User-Agent': UA } });
-    assert(docsRes.ok, `Solana llms-full.txt fetch succeeds (status=${docsRes.status})`);
-    const docsContent = await docsRes.text();
-    assert(docsContent.length > 10_000, `Solana docs has substantial content (${docsContent.length} chars)`);
-    // 2. Test section extraction for "Accounts"
-    const lines = docsContent.split('\n');
-    const accountSections = [];
-    let inSection = false;
-    let sectionDepth = 0;
-    let sectionLines = [];
-    for (const line of lines) {
-        const headerMatch = line.match(/^(#{1,4})\s+(.+)/);
-        if (headerMatch) {
-            const depth = headerMatch[1].length;
-            const title = headerMatch[2].toLowerCase();
-            if (inSection && depth <= sectionDepth) {
-                accountSections.push(sectionLines.join('\n'));
-                sectionLines = [];
-                inSection = false;
-            }
-            if (title.includes('accounts')) {
-                inSection = true;
-                sectionDepth = depth;
-                sectionLines.push(line);
-            }
-            else if (inSection) {
-                sectionLines.push(line);
-            }
-        }
-        else if (inSection) {
-            sectionLines.push(line);
-        }
-    }
-    if (inSection)
-        accountSections.push(sectionLines.join('\n'));
-    assert(accountSections.length > 0, `Found ${accountSections.length} sections matching "accounts"`);
-    // 3. Test empty queryWords edge case (the bug we fixed)
-    const shortQuery = 'a b';
-    const shortQueryLower = shortQuery.toLowerCase();
-    const shortQueryWords = shortQueryLower.split(/\s+/).filter((w) => w.length > 2);
-    assert(shortQueryWords.length === 0, 'Short query "a b" produces empty queryWords');
-    // With our fix, the condition `queryWords.length > 0 && queryWords.every(...)` prevents vacuous truth
-    const wouldMatchAll = shortQueryWords.length > 0 && shortQueryWords.every(() => true);
-    assert(!wouldMatchAll, 'Empty queryWords does NOT vacuously match all headers (bug fixed)');
-    // 4. Test "PDAs" query
-    const pdaLines = lines.filter((l) => l.toLowerCase().includes('pda'));
-    assert(pdaLines.length > 0, `"PDAs" finds ${pdaLines.length} matching lines in Solana docs`);
-}
-// ---------------------------------------------------------------------------
-// Test: fetchHeliusBlog
-// ---------------------------------------------------------------------------
-async function testFetchHeliusBlog() {
-    console.log('\n--- fetchHeliusBlog ---');
-    // 1. Test blog index size
-    const BLOG_INDEX_SIZE = 55; // approximate — we have ~55 curated posts
-    // We can't import the actual index, so just validate the fetch works
-    // 2. Fetch a known blog post
-    const blogUrl = 'https://www.helius.dev/blog/solana-virtual-machine';
-    const blogRes = await fetch(blogUrl, { headers: { 'User-Agent': UA } });
-    assert(blogRes.ok, `Blog post "solana-virtual-machine" fetch succeeds (status=${blogRes.status})`);
-    const html = await blogRes.text();
-    assert(html.length > 1000, `Blog HTML has content (${html.length} chars)`);
-    // 3. Test htmlToText conversion
-    const hasArticle = /<article/i.test(html);
-    const hasMain = /<main/i.test(html);
-    assert(hasArticle || hasMain, `Blog HTML has <article> or <main> tag for content extraction`);
-    // Basic HTML-to-text test
-    const simpleHtml = '<h2>Test Header</h2><p>Some <strong>bold</strong> text.</p>';
-    const converted = simpleHtml
-        .replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, '\n## $1\n')
-        .replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, '\n$1\n')
-        .replace(/<(?:strong|b)[^>]*>([\s\S]*?)<\/(?:strong|b)>/gi, '**$1**')
-        .replace(/<[^>]+>/g, '')
-        .trim();
-    assert(converted.includes('## Test Header'), 'h2 converted to ## markdown');
-    assert(converted.includes('**bold**'), 'strong converted to **bold**');
-    // 4. Test a non-existent slug returns error
-    const badBlogUrl = 'https://www.helius.dev/blog/this-post-does-not-exist-12345';
-    const badBlogRes = await fetch(badBlogUrl, { headers: { 'User-Agent': UA } });
-    // Helius might return 200 with a "not found" page or 404 — either way test completes
-    console.log(`${WARN} Non-existent blog slug returns status=${badBlogRes.status} (expected 404 or redirect)`);
-    // 5. Fetch another post to verify consistency
-    const blog2Url = 'https://www.helius.dev/blog/alpenglow';
-    const blog2Res = await fetch(blog2Url, { headers: { 'User-Agent': UA } });
-    assert(blog2Res.ok, `Blog post "alpenglow" fetch succeeds (status=${blog2Res.status})`);
-}
-// ---------------------------------------------------------------------------
-// Run all tests
-// ---------------------------------------------------------------------------
-async function main() {
-    console.log('=== Solana Knowledge Tools — Integration Tests ===\n');
-    try {
-        await testGetSIMD();
-    }
-    catch (e) {
-        console.log(`${FAIL} getSIMD test threw: ${e}`);
-        failed++;
-    }
-    try {
-        await testListSIMDs();
-    }
-    catch (e) {
-        console.log(`${FAIL} listSIMDs test threw: ${e}`);
-        failed++;
-    }
-    try {
-        await testReadSolanaSourceFile();
-    }
-    catch (e) {
-        console.log(`${FAIL} readSolanaSourceFile test threw: ${e}`);
-        failed++;
-    }
-    try {
-        await testSearchSolanaDocs();
-    }
-    catch (e) {
-        console.log(`${FAIL} searchSolanaDocs test threw: ${e}`);
-        failed++;
-    }
-    try {
-        await testFetchHeliusBlog();
-    }
-    catch (e) {
-        console.log(`${FAIL} fetchHeliusBlog test threw: ${e}`);
-        failed++;
-    }
-    console.log(`\n=== Results: ${passed} passed, ${failed} failed ===`);
-    process.exit(failed > 0 ? 1 : 0);
-}
-main();
-export {};

package/dist/scripts/validate-templates.d.ts

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-/**
- * Validates recommendStack template data for correctness.
- *
- * Checks:
- * 1. MCP tool names exist in KNOWN_TOOLS
- * 2. Reference paths exist on disk
- * 3. Plan-feature compatibility (e.g., Laserstream mainnet requires professional)
- * 4. Tier ordering (budget <= standard <= production plan rank)
- * 5. No empty arrays (products, limitations, references)
- */
-export {};

package/dist/scripts/validate-templates.js

@@ -1,94 +0,0 @@
-#!/usr/bin/env node
-/**
- * Validates recommendStack template data for correctness.
- *
- * Checks:
- * 1. MCP tool names exist in KNOWN_TOOLS
- * 2. Reference paths exist on disk
- * 3. Plan-feature compatibility (e.g., Laserstream mainnet requires professional)
- * 4. Tier ordering (budget <= standard <= production plan rank)
- * 5. No empty arrays (products, limitations, references)
- */
-import fs from 'fs';
-import path from 'path';
-import { PROJECT_TEMPLATES, KNOWN_TOOLS } from '../tools/recommend.js';
-import { HELIUS_PLANS } from '../tools/plans.js';
-const PLAN_RANK = { free: 0, developer: 1, business: 2, professional: 3 };
-const TIER_RANK = { budget: 0, standard: 1, production: 2 };
-// Resolve skill references relative to repo root
-const REPO_ROOT = path.resolve(import.meta.dirname, '..', '..', '..');
-const SKILL_DIR = path.join(REPO_ROOT, 'helius-skills', 'helius');
-let errors = [];
-function error(templateName, msg) {
-    errors.push(`[${templateName}] ${msg}`);
-}
-for (const [key, template] of Object.entries(PROJECT_TEMPLATES)) {
-    // ── Check tier ordering ──
-    const sorted = [...template.tiers].sort((a, b) => TIER_RANK[a.tier] - TIER_RANK[b.tier]);
-    for (let i = 1; i < sorted.length; i++) {
-        const prev = sorted[i - 1];
-        const curr = sorted[i];
-        if ((PLAN_RANK[curr.minimumPlan] ?? 0) < (PLAN_RANK[prev.minimumPlan] ?? 0)) {
-            error(key, `Tier ordering violation: ${curr.tier} (${curr.minimumPlan}) has lower plan rank than ${prev.tier} (${prev.minimumPlan})`);
-        }
-    }
-    for (const tier of template.tiers) {
-        const tierLabel = `${key}/${tier.tier}`;
-        // ── No empty arrays ──
-        if (tier.products.length === 0) {
-            error(tierLabel, 'products array is empty');
-        }
-        if (tier.limitations.length === 0) {
-            error(tierLabel, 'limitations array is empty');
-        }
-        if (tier.references.length === 0) {
-            error(tierLabel, 'references array is empty');
-        }
-        // ── Validate each product ──
-        for (const product of tier.products) {
-            // MCP tool name validation
-            for (const tool of product.mcpTools) {
-                if (!KNOWN_TOOLS.has(tool)) {
-                    error(tierLabel, `Unknown MCP tool "${tool}" in product "${product.product}"`);
-                }
-            }
-            // Plan-feature compatibility
-            if (!(product.minimumPlan in PLAN_RANK)) {
-                error(tierLabel, `Unknown plan "${product.minimumPlan}" in product "${product.product}"`);
-            }
-            if (!(product.minimumPlan in HELIUS_PLANS)) {
-                error(tierLabel, `Plan "${product.minimumPlan}" not found in HELIUS_PLANS for product "${product.product}"`);
-            }
-            // Laserstream mainnet must require professional
-            const nameLower = product.product.toLowerCase();
-            if (nameLower.includes('laserstream') && nameLower.includes('mainnet') && product.minimumPlan !== 'professional') {
-                error(tierLabel, `Laserstream mainnet in product "${product.product}" requires professional plan, but has "${product.minimumPlan}"`);
-            }
-            // Enhanced WebSockets must require business+
-            if (nameLower.includes('enhanced websocket') && (PLAN_RANK[product.minimumPlan] ?? 0) < PLAN_RANK['business']) {
-                error(tierLabel, `Enhanced WebSockets in product "${product.product}" requires business+ plan, but has "${product.minimumPlan}"`);
-            }
-        }
-        // ── Reference path validation ──
-        for (const ref of tier.references) {
-            const refPath = path.join(SKILL_DIR, ref);
-            if (!fs.existsSync(refPath)) {
-                error(tierLabel, `Reference file not found: ${ref} (looked at ${refPath})`);
-            }
-        }
-    }
-}
-// ── Report ──
-if (errors.length > 0) {
-    console.error(`\n❌ Template validation failed with ${errors.length} error(s):\n`);
-    for (const err of errors) {
-        console.error(`  • ${err}`);
-    }
-    console.error('');
-    process.exit(1);
-}
-else {
-    const templateCount = Object.keys(PROJECT_TEMPLATES).length;
-    const tierCount = Object.values(PROJECT_TEMPLATES).reduce((sum, t) => sum + t.tiers.length, 0);
-    console.log(`✅ All templates valid (${templateCount} templates, ${tierCount} tiers)`);
-}