@santi020k/lumen-mcp 1.0.0 → 1.2.0

package/dist/tools.js

@@ -53,6 +53,16 @@ const componentSummary = (component) => ({
     name: component.name,
     recipes: component.recipes.map(recipe => recipe.name)
 });
+const availableNativePlatforms = (component) => Object.keys(component.implementations);
+const nativeComponentSummary = (component) => ({
+    accessibility: component.accessibility,
+    category: component.category,
+    id: component.id,
+    name: component.name,
+    platforms: availableNativePlatforms(component),
+    summary: component.summary,
+    tier: component.tier
+});
 export const resolveComponent = (name, data = loadLumenData()) => {
     const target = normalize(name);
     return (data.components.find(component => component.name === name) ??
@@ -63,6 +73,14 @@ export const resolveRecipe = (name, data = loadLumenData()) => {
     const target = normalize(name);
     return data.recipes.find(recipe => normalize(recipe.name) === target);
 };
+export const resolveNativeComponent = (name, data = loadLumenData()) => {
+    const target = normalize(name);
+    return data.nativeComponents.find(component => (component.name === name ||
+        normalize(component.name) === target ||
+        normalize(component.id) === target ||
+        Object.values(component.implementations).some(implementation => (normalize(implementation.exportName) === target ||
+            normalize(implementation.symbol) === target))));
+};
 const frameworkBehaviorSearchText = (behavior) => [
     behavior?.description ?? '',
     behavior?.hook ?? '',
@@ -99,6 +117,28 @@ const componentSearchText = (component, framework) => [
         .join(' '),
     frameworkSearchText(component, framework)
 ].join(' ');
+const nativeImplementationSearchText = (implementation) => [
+    implementation.exportName,
+    implementation.symbol,
+    implementation.packageName,
+    implementation.importStatement,
+    implementation.api.map(row => (`${row.name} ${row.values} ${row.description}`)).join(' '),
+    implementation.example
+].join(' ');
+const nativeComponentSearchText = (component, platform) => [
+    component.name,
+    component.id,
+    component.summary,
+    component.category,
+    component.contract,
+    component.guidance,
+    component.accessibility,
+    component.tier,
+    platform ?? '',
+    ...(platform ?
+        [component.implementations[platform]].filter((implementation) => Boolean(implementation)) :
+        Object.values(component.implementations)).map(nativeImplementationSearchText)
+].join(' ');
 const scoreCandidate = (query, terms, searchableText, primaryName = '') => {
     const normalizedText = normalize(searchableText);
     const matchedTerms = terms.filter(term => (Reflect.get(searchTermAliases, term) ?? [term]).some(candidate => normalizedText.includes(candidate)));
@@ -121,14 +161,19 @@ const scoreCandidate = (query, terms, searchableText, primaryName = '') => {
         score += 500;
     return { matchedTerms, score };
 };
-const appendSearchResult = (results, candidate, query, terms, searchableText) => {
+const appendSearchResult = (results, candidate, query, terms, searchableText, scoreAdjustment = 0) => {
     const match = scoreCandidate(query, terms, searchableText, candidate.kind === 'rule' ? '' : candidate.name);
-    if (match.score > 0)
-        results.push({ ...candidate, ...match });
+    if (match.score > 0) {
+        results.push({
+            ...candidate,
+            ...match,
+            score: Math.max(1, match.score + scoreAdjustment)
+        });
+    }
 };
-const collectSearchResults = (query, terms, data, framework) => {
+const collectComponentSearchResults = (query, terms, data, framework, platform) => {
     const results = [];
-    for (const component of data.components) {
+    for (const component of platform ? [] : data.components) {
         if (framework && !Reflect.get(component.frameworks, framework))
             continue;
         appendSearchResult(results, {
@@ -139,6 +184,23 @@ const collectSearchResults = (query, terms, data, framework) => {
             name: component.name
         }, query, terms, componentSearchText(component, framework));
     }
+    if (!platform || framework)
+        return results;
+    for (const component of data.nativeComponents) {
+        if (!component.implementations[platform])
+            continue;
+        appendSearchResult(results, {
+            category: component.category,
+            description: component.summary,
+            kind: 'native-component',
+            name: component.name,
+            platforms: availableNativePlatforms(component)
+        }, query, terms, nativeComponentSearchText(component, platform));
+    }
+    return results;
+};
+const collectReferenceSearchResults = (query, terms, data) => {
+    const results = [];
     for (const recipe of data.recipes) {
         appendSearchResult(results, {
             category: recipe.categories.join(', '),
@@ -163,6 +225,10 @@ const collectSearchResults = (query, terms, data, framework) => {
     }
     return results;
 };
+const collectSearchResults = (query, terms, data, framework, platform) => [
+    ...collectComponentSearchResults(query, terms, data, framework, platform),
+    ...collectReferenceSearchResults(query, terms, data)
+];
 export const listComponents = (args = {}, data = loadLumenData()) => {
     const query = args.query?.trim();
     const queryTerms = query ? meaningfulSearchTerms(query) : [];
@@ -348,6 +414,101 @@ export const getComponent = (args, data = loadLumenData()) => {
         text: formatComponentUsage(component, framework, detail)
     };
 };
+export const listNativeComponents = (args = {}, data = loadLumenData()) => {
+    const query = args.query?.trim();
+    const terms = query ? meaningfulSearchTerms(query) : [];
+    const components = data.nativeComponents.filter(component => ((!args.platform || Boolean(component.implementations[args.platform])) &&
+        (!query || scoreCandidate(query, terms, nativeComponentSearchText(component, args.platform), component.name).score > 0))).map(nativeComponentSummary);
+    return {
+        data: { components, count: components.length },
+        text: components.length === 0 ?
+            'No native components matched the given filters.' :
+            `${components.length} native component(s):\n\n${components.map(component => (`${component.name} (${component.id}) — ${component.summary} — ${component.platforms.join(', ')}`)).join('\n')}`
+    };
+};
+const nativeComponentDetail = (component, platform, detail, data) => {
+    const implementation = component.implementations[platform];
+    if (!implementation)
+        return undefined;
+    const common = {
+        ...nativeComponentSummary(component),
+        contract: component.contract,
+        guidance: component.guidance,
+        platform
+    };
+    if (detail === 'summary') {
+        return {
+            ...common,
+            implementation: {
+                exportName: implementation.exportName,
+                packageName: implementation.packageName,
+                symbol: implementation.symbol
+            }
+        };
+    }
+    const usage = { ...common, implementation };
+    return detail === 'source' ?
+        {
+            ...usage,
+            source: data.nativeSources[platform][implementation.sourceFile]
+        } :
+        usage;
+};
+const formatNativeComponent = (component, platform, detail, data) => {
+    const implementation = component.implementations[platform];
+    if (!implementation)
+        return '';
+    const sections = [
+        `# ${component.name}`,
+        component.summary,
+        `Category: ${component.category}`,
+        `Tier: ${component.tier}`,
+        `Platform: ${platform}`,
+        `Available platforms: ${availableNativePlatforms(component).join(', ')}`,
+        `Package: ${implementation.packageName}`,
+        `Install: ${implementation.install}`,
+        `Import: ${implementation.importStatement}`,
+        `Setup: ${implementation.setup}`,
+        '',
+        '## Accessibility',
+        component.accessibility,
+        '',
+        '## Contract',
+        component.contract,
+        '',
+        '## Guidance',
+        component.guidance
+    ];
+    if (detail === 'summary')
+        return sections.join('\n');
+    if (implementation.api.length > 0) {
+        sections.push('', '## API', ...implementation.api.map(row => (`- \`${row.name}\` ${row.values} (default: ${row.defaultValue}) — ${row.description}`)));
+    }
+    sections.push('', '## Example', `\`\`\`${implementation.language}`, implementation.example, '```');
+    if (detail === 'source') {
+        sections.push('', `## Reference source (${implementation.sourceFile})`, `\`\`\`${implementation.language}`, data.nativeSources[platform][implementation.sourceFile]?.trimEnd() ?? '', '```');
+    }
+    return sections.join('\n');
+};
+export const getNativeComponent = (args, data = loadLumenData()) => {
+    const component = resolveNativeComponent(args.name, data);
+    if (!component) {
+        const message = `Unknown native component "${args.name}". Use lumen_list_native_components to see available names.`;
+        return { data: { found: false, message }, isError: true, text: message };
+    }
+    if (!component.implementations[args.platform]) {
+        const message = `${component.name} is not available for ${args.platform}. Available platforms: ${availableNativePlatforms(component).join(', ')}.`;
+        return { data: { found: false, message }, isError: true, text: message };
+    }
+    const detail = args.detail ?? 'usage';
+    return {
+        data: {
+            component: nativeComponentDetail(component, args.platform, detail, data),
+            found: true
+        },
+        text: formatNativeComponent(component, args.platform, detail, data)
+    };
+};
 export const getRecipe = (args, data = loadLumenData()) => {
     const recipe = resolveRecipe(args.name, data);
     if (!recipe) {
@@ -389,12 +550,13 @@ export const search = (args, data = loadLumenData()) => {
         };
     }
     const limit = Math.max(1, Math.min(args.limit ?? 20, 100));
-    const results = collectSearchResults(query, meaningfulSearchTerms(query), data, args.framework);
+    const results = collectSearchResults(query, meaningfulSearchTerms(query), data, args.framework, args.platform);
     const kindPriority = {
         component: 0,
-        recipe: 1,
-        rule: 3,
-        token: 2
+        'native-component': 1,
+        recipe: 2,
+        rule: 4,
+        token: 3
     };
     results.sort((left, right) => right.score - left.score ||
         kindPriority[left.kind] - kindPriority[right.kind] ||
@@ -418,7 +580,8 @@ export const getMeta = (data = loadLumenData()) => ({
         `Server version: ${data.meta.serverVersion}`,
         `Schema version: ${data.meta.schemaVersion}`,
         `Catalog hash: ${data.meta.catalogHash}`,
-        `Components: ${data.meta.componentCount}`,
+        `Web components: ${data.meta.componentCount}`,
+        `Native components: ${data.meta.nativeComponentCount}`,
         '',
         '## Package versions',
         ...Object.entries(data.meta.packageVersions).map(([name, version]) => `- ${name}: ${version}`)
@@ -453,6 +616,7 @@ export const getCatalogManifest = (data = loadLumenData()) => ({
         '# Lumen catalog manifest',
         `Catalog hash: ${data.meta.catalogHash}`,
         `Components: ${Object.keys(data.catalogManifest.components).length}`,
+        `Native components: ${Object.keys(data.catalogManifest.nativeComponents ?? {}).length}`,
         `Recipes: ${Object.keys(data.catalogManifest.recipes).length}`,
         '',
         'Keep this structured result and pass its manifest to lumen_diff_catalog after an MCP update.'
@@ -461,10 +625,14 @@ export const getCatalogManifest = (data = loadLumenData()) => ({
 export const diffCatalog = (args, data = loadLumenData()) => {
     const components = diffManifestSection(data.catalogManifest.components, args.baseline.components);
     const recipes = diffManifestSection(data.catalogManifest.recipes, args.baseline.recipes);
+    const nativeComponents = diffManifestSection(data.catalogManifest.nativeComponents ?? {}, args.baseline.nativeComponents ?? {});
     const changedCount = [
         ...components.added,
         ...components.changed,
         ...components.removed,
+        ...nativeComponents.added,
+        ...nativeComponents.changed,
+        ...nativeComponents.removed,
         ...recipes.added,
         ...recipes.changed,
         ...recipes.removed
@@ -476,6 +644,7 @@ export const diffCatalog = (args, data = loadLumenData()) => {
         data: {
             components,
             currentCatalogHash: data.meta.catalogHash,
+            nativeComponents,
             recipes,
             unchanged
         },
@@ -487,21 +656,16 @@ export const diffCatalog = (args, data = loadLumenData()) => {
                 `Changed entries: ${changedCount}`,
                 `Components — added: ${components.added.length}, changed: ${components.changed.length}, ` +
                     `removed: ${components.removed.length}`,
+                `Native components — added: ${nativeComponents.added.length}, changed: ${nativeComponents.changed.length}, ` +
+                    `removed: ${nativeComponents.removed.length}`,
                 `Recipes — added: ${recipes.added.length}, changed: ${recipes.changed.length}, ` +
                     `removed: ${recipes.removed.length}`
             ].join('\n')
     };
 };
-export const diagnose = (data = loadLumenData()) => {
+const webDiagnosticChecks = (data) => {
     const componentNames = data.components.map(component => component.name);
-    const frameworkCoverage = {
-        astro: data.components.filter(component => component.frameworks.astro)
-            .length,
-        elements: data.components.filter(component => component.frameworks.elements).length,
-        react: data.components.filter(component => component.frameworks.react)
-            .length
-    };
-    const checks = [
+    return [
         {
             message: `${data.components.length} component records match metadata.`,
             name: 'component-count',
@@ -528,24 +692,76 @@ export const diagnose = (data = loadLumenData()) => {
                 if (!available)
                     return true;
                 const details = Reflect.get(component.frameworkDetails, framework);
-                return (Boolean(details?.example.trim()) &&
-                    Boolean(details?.importStatement.trim()));
+                return Boolean(details?.example.trim()) && Boolean(details?.importStatement.trim());
             })) ?
                 'pass' :
                 'fail'
         }
     ];
+};
+const nativeDiagnosticChecks = (data) => {
+    const nativeComponentNames = data.nativeComponents.map(component => component.name);
+    return [
+        {
+            message: `${data.nativeComponents.length} native component records match metadata.`,
+            name: 'native-component-count',
+            status: data.nativeComponents.length === data.meta.nativeComponentCount ?
+                'pass' :
+                'fail'
+        },
+        {
+            message: 'Native component names and ids are unique.',
+            name: 'unique-native-components',
+            status: new Set(nativeComponentNames).size === nativeComponentNames.length &&
+                new Set(data.nativeComponents.map(component => component.id)).size === data.nativeComponents.length ?
+                'pass' :
+                'fail'
+        },
+        {
+            message: 'Every native component has a manifest fingerprint.',
+            name: 'native-component-manifest',
+            status: nativeComponentNames.every(name => (Reflect.get(data.catalogManifest.nativeComponents ?? {}, name))) ?
+                'pass' :
+                'fail'
+        },
+        {
+            message: 'Every native implementation has usage, import, and bundled reference source.',
+            name: 'native-contracts',
+            status: data.nativeComponents.every(component => (Object.entries(component.implementations).every(([platform, implementation]) => (Boolean(implementation.example.trim()) &&
+                Boolean(implementation.importStatement.trim()) &&
+                Boolean(data.nativeSources[platform][implementation.sourceFile]?.trim()))))) ?
+                'pass' :
+                'fail'
+        }
+    ];
+};
+export const diagnose = (data = loadLumenData()) => {
+    const frameworkCoverage = {
+        astro: data.components.filter(component => component.frameworks.astro)
+            .length,
+        elements: data.components.filter(component => component.frameworks.elements).length,
+        react: data.components.filter(component => component.frameworks.react)
+            .length
+    };
+    const nativeCoverage = {
+        compose: data.nativeComponents.filter(component => component.implementations.compose).length,
+        'react-native': data.nativeComponents.filter(component => component.implementations['react-native']).length,
+        swiftui: data.nativeComponents.filter(component => component.implementations.swiftui).length
+    };
+    const checks = [...webDiagnosticChecks(data), ...nativeDiagnosticChecks(data)];
     const status = checks.every(check => check.status === 'pass') ?
         'healthy' :
         'issues';
     return {
-        data: { checks, frameworkCoverage, status },
+        data: { checks, frameworkCoverage, nativeCoverage, status },
         isError: status === 'issues',
         text: [
             `# Lumen MCP diagnostics: ${status}`,
             `Catalog hash: ${data.meta.catalogHash}`,
             `Framework coverage — Astro: ${frameworkCoverage.astro}, ` +
                 `React: ${frameworkCoverage.react}, Elements: ${frameworkCoverage.elements}`,
+            `Native coverage — React Native: ${nativeCoverage['react-native']}, ` +
+                `SwiftUI: ${nativeCoverage.swiftui}, Compose: ${nativeCoverage.compose}`,
             '',
             ...checks.map(check => `- ${check.status.toUpperCase()} ${check.name}: ${check.message}`)
         ].join('\n')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@santi020k/lumen-mcp",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "publishConfig": {
     "access": "public"
   },
@@ -33,7 +33,7 @@
     "lumen-mcp-http": "./bin/lumen-mcp-http.mjs"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
@@ -52,7 +52,7 @@
     "url": "https://github.com/santi020k/lumen.git",
     "directory": "packages/mcp"
   },
-  "homepage": "https://lumen.santi020k.com",
+  "homepage": "https://lumen.santi020k.com/docs/mcp",
   "bugs": {
     "url": "https://github.com/santi020k/lumen/issues"
   },