@taiga-ui/mcp 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2024 Acpekt
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,137 @@
+# Taiga UI MCP Server
+
+> **🚀 The fastest way to integrate Taiga UI components into your AI workflow**
+
+A Model Context Protocol (MCP) server that provides AI assistants with comprehensive access to [Taiga UI](https://taiga-ui.dev) components. Seamlessly retrieve Taiga UI components implementations for your AI-powered development workflow.
+
+## Integrate with Your Editor
+
+### VS Code
+
+To configure MCP in VS Code with GitHub Copilot, add the taiga-ui server to your project's `.vscode/mcp.json` configuration file:
+
+```json
+{
+    "mcpServers": {
+        "taiga-ui": {
+            "command": "npx",
+            "args": [
+                "@taiga-ui/mcp@latest",
+                "--source-url=https://taiga-ui.dev/llms-full.txt" // or file from "/next" version, if you want
+            ]
+        }
+    }
+}
+```
+
+## Provided Tools
+
+1. `get_list_components { query?: string }`
+
+    - Lists component / section identifiers (with fuzzy substring filtering) along with basic metadata (category, package, type).
+    - Input: optional `query` string to filter IDs (case-insensitive substring).
+    - Output: `{ items: [...], total, query }` strictly structured JSON.
+
+```
+{
+   "items": [
+      { "id": "components/Alert", "name": "Alert", "category": "components", "package": "CORE", "type": "component" }
+   ],
+   "total": 1,
+   "query": null
+}
+```
+
+2. `get_component_example { "names": ["...", "..."] }`
+
+    - Returns the full markdown content of each resolved section (entire component documentation). Applies fuzzy name resolution (variants: exact, segment, suffix, substring with Tui\* variants).
+    - Input: `{ names: string[] }` (each >= 2 chars).
+    - Output: per name object with `id` (present only if resolved), `package`, `type`, `suggestions` (only when unresolved), and `content` (array of code strings when example blocks exist; omitted otherwise). Top-level also includes `matched` (count of resolved names).
+
+```
+{
+   "results": [
+      {
+         "query": "Alert",
+         "id": "components/Alert",
+         "package": "CORE",
+         "type": "component",
+         "content": ["# components/Alert\n- **Package**: ... (full section markdown here)"]
+      }
+   ],
+    "matched": 1
+}
+```
+
+## Authors
+
+<table>
+    <tr> 
+        <td align="center">
+            <a href="https://github.com/vladimirpotekhin"
+                ><img
+                    src="https://github.com/vladimirpotekhin.png?size=200"
+                    width="100"
+                    style="margin-bottom: -4px; border-radius: 8px;"
+                    alt="Vladimir Potekhin"
+                /><br /><b>Vladimir&nbsp;Potekhin</b></a
+            >
+            <div style="margin-top: 4px">
+                <a
+                    href="https://twitter.com/v_potekhin"
+                    title="Twitter"
+                    ><img
+                        width="16"
+                        src="https://raw.githubusercontent.com/MarsiBarsi/readme-icons/main/twitter.svg"
+                /></a>
+                <a
+                    href="https://github.com/vladimirpotekhin"
+                    title="GitHub"
+                    ><img
+                        width="16"
+                        src="https://raw.githubusercontent.com/MarsiBarsi/readme-icons/main/github.svg"
+                /></a>
+                <a
+                    href="https://t.me/v_potekhin"
+                    title="Telegram"
+                    ><img
+                        width="16"
+                        src="https://raw.githubusercontent.com/MarsiBarsi/readme-icons/main/send.svg"
+                /></a>
+            </div>
+        </td> 
+        <td align="center">
+            <a href="https://github.com/mdlufy"
+                ><img
+                    src="https://github.com/mdlufy.png?size=200"
+                    width="100"
+                    style="margin-bottom: -4px; border-radius: 8px;"
+                    alt="German Panov"
+                /><br /><b>German&nbsp;Panov</b></a
+            >
+            <div style="margin-top: 4px">
+                <a
+                    href="https://twitter.com/mdlufy_"
+                    title="Twitter"
+                    ><img
+                        width="16"
+                        src="https://raw.githubusercontent.com/MarsiBarsi/readme-icons/main/twitter.svg"
+                /></a>
+                <a
+                    href="https://github.com/mdlufy"
+                    title="GitHub"
+                    ><img
+                        width="16"
+                        src="https://raw.githubusercontent.com/MarsiBarsi/readme-icons/main/github.svg"
+                /></a>
+                <a
+                    href="https://t.me/mdlufy"
+                    title="Telegram"
+                    ><img
+                        width="16"
+                        src="https://raw.githubusercontent.com/MarsiBarsi/readme-icons/main/send.svg"
+                /></a>
+            </div>
+        </td>
+    </tr>
+</table>

package/dist/index.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { start } from './server/server.js';
+import { logError } from './utils/logger.js';
+start().catch((err) => {
+    logError('Unhandled startup error', err);
+    process.exit(1);
+});

package/dist/schemas/doc-types.js

@@ -0,0 +1 @@
+export {};

package/dist/server/fetch.js

@@ -0,0 +1,31 @@
+import { state } from './server.js';
+import { parseContent } from '../utils/parse-content.js';
+// 6-hour refresh window
+const REFRESH_INTERVAL_MS = 6 * 60 * 60 * 1000;
+export async function fetchSource() {
+    const argProvidedUrl = process.argv
+        .find((arg) => arg.startsWith('--source-url='))
+        ?.split('=')[1];
+    const sourceUrl = argProvidedUrl || process.env.SOURCE_URL;
+    if (!sourceUrl) {
+        throw new Error('Source URL not provided. Set SOURCE_URL or pass --source-url=...');
+    }
+    const response = await fetch(sourceUrl).catch((error) => {
+        throw new Error(`Network error fetching documentation source: ${error?.message || error}`);
+    });
+    if (!response.ok)
+        throw new Error(`Failed to fetch documentation (HTTP ${response.status} ${response.statusText}) from ${sourceUrl}`);
+    const content = await response.text();
+    if (!content.trim())
+        throw new Error(`Fetched documentation from ${sourceUrl} is empty.`);
+    return { url: sourceUrl, content };
+}
+export async function ensureSourceLoaded() {
+    const isContentStale = !state.lastLoadedAt ||
+        Date.now() - state.lastLoadedAt > REFRESH_INTERVAL_MS;
+    if (!(state.sections.length > 0) || isContentStale) {
+        const { url, content } = await fetchSource();
+        parseContent(content, url);
+        state.lastLoadedAt = Date.now();
+    }
+}

package/dist/server/server.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ensureSourceLoaded } from './fetch.js';
+import { registerAllTools } from '../tools/index.js';
+export const state = {
+    sections: [],
+    sourceUrl: undefined,
+    lastLoadedAt: undefined,
+};
+const server = new McpServer({
+    name: 'taiga-ui-mcp',
+    version: '0.1.0-alpha.1',
+});
+registerAllTools(server);
+export async function start() {
+    try {
+        await ensureSourceLoaded();
+    }
+    catch (error) {
+        console.error('Initial source load failed:', error);
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`Angular Taiga UI MCP Server running. Fetched source components: ${state.sections.length}`);
+}

package/dist/tools/get-component-example.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { ensureSourceLoaded } from '../server/fetch.js';
+import { buildQueryResults } from '../utils/query-results.js';
+export function registerGetComponentExampleTool(server) {
+    server.registerTool('get_component_example', {
+        title: 'Get Component Example',
+        description: 'Return section-related content snippets (formerly examples) for specified documentation section name(s). The presence of id indicates a successful match.',
+        inputSchema: { names: z.array(z.string().min(2)).min(1) },
+        outputSchema: {
+            results: z.array(z.object({
+                query: z.string(),
+                id: z.string().optional(),
+                package: z.string().nullable().optional(),
+                type: z.string().nullable().optional(),
+                suggestions: z.array(z.string()).optional(),
+                content: z.array(z.string()).optional(),
+            })),
+            matched: z.number(),
+        },
+    }, async ({ names }) => {
+        if (!names || !names.length) {
+            const output = {
+                error: 'Provide at least one name in names array.',
+            };
+            return {
+                content: [
+                    { type: 'text', text: JSON.stringify(output, null, 2) },
+                ],
+                structuredContent: output,
+            };
+        }
+        await ensureSourceLoaded();
+        const { results, matches } = buildQueryResults(names);
+        const output = { results, matched: matches };
+        return {
+            content: [
+                { type: 'text', text: JSON.stringify(output, null, 2) },
+            ],
+            structuredContent: output,
+        };
+    });
+}

package/dist/tools/get-list-components.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { ensureSourceLoaded } from '../server/fetch.js';
+import { constructComponentsList } from '../utils/list-components.js';
+export function registerGetListComponentsTool(server) {
+    server.registerTool('get_list_components', {
+        title: 'List Components',
+        description: 'List all Taiga UI documentation section IDs (structured JSON only).',
+        inputSchema: { query: z.string().optional() },
+        outputSchema: {
+            items: z.array(z.object({
+                id: z.string(),
+                name: z.string(),
+                category: z.string(),
+                package: z.string().nullable(),
+                type: z.string().nullable(),
+            })),
+            total: z.number(),
+            query: z.string().nullable(),
+        },
+    }, async ({ query }) => {
+        await ensureSourceLoaded();
+        const { items, normalizedQuery } = constructComponentsList(query);
+        const output = {
+            items,
+            total: items.length,
+            query: normalizedQuery,
+        };
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(output, null, 2),
+                },
+            ],
+            structuredContent: output,
+        };
+    });
+}

package/dist/tools/index.js

@@ -0,0 +1,6 @@
+import { registerGetListComponentsTool } from './get-list-components.js';
+import { registerGetComponentExampleTool } from './get-component-example.js';
+export function registerAllTools(server) {
+    registerGetListComponentsTool(server);
+    registerGetComponentExampleTool(server);
+}

package/dist/utils/find-section.js

@@ -0,0 +1,64 @@
+import { state } from '../server/server.js';
+export function findSection(name) {
+    const pascalCase = name
+        .toLowerCase()
+        .split(/[-_\s]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+    const camelCase = pascalCase
+        ? pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1)
+        : '';
+    const tuiVariant = pascalCase.startsWith('Tui')
+        ? pascalCase
+        : 'Tui' + pascalCase;
+    const variants = [
+        name.toLowerCase(),
+        pascalCase,
+        camelCase,
+        tuiVariant,
+        tuiVariant.toLowerCase(),
+    ].filter(Boolean);
+    // Exact match
+    for (const variant of variants) {
+        const exactMatch = state.sections.find((section) => section.id.toLowerCase() === variant.toLowerCase());
+        if (exactMatch)
+            return exactMatch;
+    }
+    // Last path segment match
+    for (const variant of variants) {
+        const segmentMatch = state.sections.find((section) => section.id.split('/').pop()?.toLowerCase() ===
+            variant.toLowerCase());
+        if (segmentMatch)
+            return segmentMatch;
+    }
+    // Ends-with match
+    for (const variant of variants) {
+        const endsWithMatch = state.sections.find((section) => section.id.toLowerCase().endsWith('/' + variant.toLowerCase()));
+        if (endsWithMatch)
+            return endsWithMatch;
+    }
+    // Substring fallback
+    const substringMatch = state.sections.find((section) => section.id.toLowerCase().includes(name.toLowerCase()));
+    if (substringMatch)
+        return substringMatch;
+    return undefined;
+}
+export function suggestSections(query) {
+    const normalizedQuery = query.toLowerCase();
+    return state.sections
+        .map((section) => {
+        const sectionIdLower = section.id.toLowerCase();
+        const matchIndex = sectionIdLower.indexOf(normalizedQuery);
+        return matchIndex === -1
+            ? null
+            : {
+                id: section.id,
+                score: matchIndex * 10 +
+                    Math.abs(sectionIdLower.length - normalizedQuery.length),
+            };
+    })
+        .filter((candidate) => !!candidate)
+        .sort((a, b) => a.score - b.score)
+        .map((result) => result.id);
+}

package/dist/utils/list-components.js

@@ -0,0 +1,20 @@
+import { state } from '../server/server.js';
+export function constructComponentsList(query) {
+    const normalizedQuery = query ? query.toLowerCase() : null;
+    const items = state.sections
+        .filter((section) => !normalizedQuery ||
+        section.id.toLowerCase().includes(normalizedQuery))
+        .map((section) => {
+        const idParts = section.id.split('/');
+        const name = idParts[idParts.length - 1] || section.id;
+        const category = idParts[0] || '';
+        return {
+            id: section.id,
+            name,
+            category,
+            package: section.package ?? null,
+            type: section.kind ?? null,
+        };
+    });
+    return { items, normalizedQuery };
+}

package/dist/utils/logger.js

@@ -0,0 +1,7 @@
+export function logError(message, err) {
+    const stack = err instanceof Error ? err.stack || err.message : String(err);
+    console.error(`[ERROR] ${message}: ${stack}`);
+}
+export function logInfo(message) {
+    console.error(`[INFO] ${message}`);
+}

package/dist/utils/parse-content.js

@@ -0,0 +1,38 @@
+import { state } from '../server/server.js';
+function extractMeta(text) {
+    let pkg;
+    let kind;
+    const pkgMatch = /\*\*Package\*\*:\s*`([^`]+)`/i.exec(text);
+    if (pkgMatch)
+        pkg = pkgMatch[1];
+    const typeMatch = /\*\*Type\*\*:\s*([^\n]+)/i.exec(text);
+    if (typeMatch)
+        kind = typeMatch[1].trim();
+    return { package: pkg, kind };
+}
+export function parseContent(rawContent, sourceUrl) {
+    state.sourceUrl = sourceUrl;
+    const lines = rawContent.split(/\r?\n/);
+    const headerIndices = [];
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const headerMatch = /^#\s+(.+)$/.exec(lines[lineIndex]);
+        if (headerMatch)
+            headerIndices.push({
+                line: lineIndex,
+                title: headerMatch[1].trim(),
+            });
+    }
+    state.sections = headerIndices.map((header, headerIndex) => {
+        const start = header.line;
+        const end = headerIndices[headerIndex + 1]?.line ?? lines.length;
+        const content = lines.slice(start, end).join('\n');
+        const meta = extractMeta(content);
+        return {
+            id: header.title,
+            title: header.title,
+            content,
+            package: meta.package,
+            kind: meta.kind,
+        };
+    });
+}

package/dist/utils/query-results.js

@@ -0,0 +1,39 @@
+import { findSection, suggestSections } from './find-section.js';
+export function extractContentSnippets(section) {
+    const text = section.content || '';
+    const trimmed = text.trim();
+    if (!trimmed)
+        return [];
+    const cleaned = trimmed
+        .split(/\r?\n/)
+        .map((line) => line.replace(/^#{1,6}\s*/, ''))
+        .join('\n')
+        .trim();
+    return cleaned ? [cleaned] : [];
+}
+export function buildQueryResults(names) {
+    const results = [];
+    for (const queryName of names) {
+        const section = findSection(queryName);
+        if (!section) {
+            const notFound = {
+                query: queryName,
+                suggestions: suggestSections(queryName),
+            };
+            results.push(notFound);
+            continue;
+        }
+        const snippets = extractContentSnippets(section);
+        const foundResult = {
+            query: queryName,
+            id: section.id,
+            package: section.package || null,
+            type: section.kind || null,
+        };
+        if (snippets.length)
+            foundResult.content = snippets;
+        results.push(foundResult);
+    }
+    const matches = results.filter((result) => !!result.id).length;
+    return { results, matches };
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+    "name": "@taiga-ui/mcp",
+    "version": "0.1.0-alpha.1",
+    "description": "Model Context Protocol server providing Taiga UI documentation search and scaffolding tools.",
+    "type": "module",
+    "main": "./dist/index.js",
+    "bin": {
+        "taiga-ui-mcp": "./dist/index.js"
+    },
+    "files": [
+        "dist/**/*",
+        "README.md",
+        "LICENSE"
+    ],
+    "keywords": [
+        "mcp",
+        "model-context-protocol",
+        "taiga-ui",
+        "taiga-ui-mcp",
+        "ui-components",
+        "typescript",
+        "ai-tools",
+        "claude",
+        "copilot"
+    ],
+    "license": "Apache-2.0",
+    "homepage": "https://github.com/taiga-family/taiga-ui-mcp#README",
+    "bugs": {
+        "url": "https://github.com/taiga-family/taiga-ui-mcp/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/taiga-family/taiga-ui-mcp.git"
+    },
+    "authors": [
+        "Vladimir Potekhin <vladimir.potekh@gmail.com>",
+        "German Panov <zidakbew@gmail.com>"
+    ],
+    "scripts": {
+        "start": "node dist/index.js",
+        "clean": "rm -rf dist",
+        "build": "npm run clean && tsc && chmod +x dist/index.js",
+        "prepublishOnly": "npm run build",
+        "release": "npm run build && npm publish --access public --tag alpha"
+    },
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.20.0",
+        "zod": "^3.25.76"
+    },
+    "devDependencies": {
+        "@taiga-ui/release-it-config": "0.344.0",
+        "@taiga-ui/auto-changelog-config": "0.344.0",
+        "@types/node": "^24.7.2",
+        "typescript": "^5.9.3"
+    }
+}