auigrid-mcp-server 0.1.0

package/dist/build-index.js

@@ -0,0 +1,95 @@
+import { Project } from "ts-morph";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function getDescription(node) {
+    const docs = node.getJsDocs();
+    if (docs.length === 0)
+        return "";
+    return docs[0]
+        .getDescription()
+        .replace(/\r\n/g, "\n")
+        .trim();
+}
+function getTag(node, tagName) {
+    for (const doc of node.getJsDocs()) {
+        for (const tag of doc.getTags()) {
+            if (tag.getTagName() === tagName) {
+                return tag.getCommentText()?.trim();
+            }
+        }
+    }
+    return undefined;
+}
+function classifyInterface(name) {
+    if (name === "Props")
+        return "grid-option";
+    if (name === "Column")
+        return "column";
+    if (name === "Footer")
+        return "footer";
+    if (name.endsWith("Renderer"))
+        return "renderer";
+    if (name.endsWith("Event"))
+        return "event";
+    return "other";
+}
+function propKindFor(ifaceKind) {
+    switch (ifaceKind) {
+        case "grid-option":
+            return "prop";
+        default:
+            return `${ifaceKind}-prop`;
+    }
+}
+const vendorPath = path.resolve(__dirname, "../vendor/auigrid-tsx.d.ts");
+const outPath = path.resolve(__dirname, "../data/api-index.json");
+const project = new Project();
+const sourceFile = project.addSourceFileAtPath(vendorPath);
+const entries = [];
+for (const iface of sourceFile.getInterfaces()) {
+    const ifaceName = iface.getName();
+    const ifaceKind = classifyInterface(ifaceName);
+    entries.push({
+        name: ifaceName,
+        kind: ifaceKind,
+        description: getDescription(iface),
+    });
+    for (const prop of iface.getProperties()) {
+        entries.push({
+            name: prop.getName(),
+            kind: propKindFor(ifaceKind),
+            parent: ifaceName,
+            type: prop.getTypeNode()?.getText() ?? prop.getType().getText(),
+            description: getDescription(prop),
+            defaultValue: getTag(prop, "defaultValue"),
+            optional: prop.hasQuestionToken(),
+        });
+    }
+}
+for (const enumDecl of sourceFile.getEnums()) {
+    const enumName = enumDecl.getName();
+    entries.push({
+        name: enumName,
+        kind: "enum",
+        description: getDescription(enumDecl),
+    });
+    for (const member of enumDecl.getMembers()) {
+        entries.push({
+            name: member.getName(),
+            kind: "enum-member",
+            parent: enumName,
+            type: member.getValue()?.toString(),
+            description: getDescription(member),
+        });
+    }
+}
+fs.mkdirSync(path.dirname(outPath), { recursive: true });
+fs.writeFileSync(outPath, JSON.stringify(entries, null, 2), "utf-8");
+const byKind = new Map();
+for (const e of entries)
+    byKind.set(e.kind, (byKind.get(e.kind) ?? 0) + 1);
+console.error(`Wrote ${entries.length} entries to ${outPath}`);
+for (const [kind, count] of byKind)
+    console.error(`  ${kind}: ${count}`);

package/dist/build-methods-index.js

@@ -0,0 +1,14 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseDocPage } from "./lib/docPageParser.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const srcPath = path.resolve(__dirname, "../vendor/docs/DataGrid-Methods.html");
+const outPath = path.resolve(__dirname, "../data/methods-index.json");
+const html = fs.readFileSync(srcPath, "utf-8");
+const entries = parseDocPage(html);
+fs.mkdirSync(path.dirname(outPath), { recursive: true });
+fs.writeFileSync(outPath, JSON.stringify(entries, null, 2), "utf-8");
+console.error(`Wrote ${entries.length} method entries to ${outPath}`);
+console.error(`  with parameters: ${entries.filter((e) => e.parameters.length > 0).length}`);
+console.error(`  with example code: ${entries.filter((e) => e.example).length}`);

package/dist/build-samples-index.js

@@ -0,0 +1,46 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const vendorRoot = path.resolve(__dirname, "../vendor/samples");
+const outPath = path.resolve(__dirname, "../data/samples-index.json");
+const CODE_EXT = new Set([".ts", ".tsx"]);
+function walk(dir, fileList = []) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walk(full, fileList);
+        }
+        else if (CODE_EXT.has(path.extname(entry.name))) {
+            fileList.push(full);
+        }
+    }
+    return fileList;
+}
+function categoryFromRelPath(relPath) {
+    const [top] = relPath.split(path.sep);
+    return top;
+}
+const entries = [];
+for (const framework of fs.readdirSync(vendorRoot, { withFileTypes: true })) {
+    if (!framework.isDirectory())
+        continue;
+    const frameworkDir = path.join(vendorRoot, framework.name);
+    const files = walk(frameworkDir);
+    for (const file of files) {
+        const relPath = path.relative(frameworkDir, file);
+        entries.push({
+            name: path.basename(file, path.extname(file)),
+            framework: framework.name,
+            category: categoryFromRelPath(relPath),
+            relPath,
+            content: fs.readFileSync(file, "utf-8"),
+        });
+    }
+}
+fs.mkdirSync(path.dirname(outPath), { recursive: true });
+fs.writeFileSync(outPath, JSON.stringify(entries, null, 2), "utf-8");
+console.error(`Wrote ${entries.length} sample files to ${outPath}`);
+for (const framework of new Set(entries.map((e) => e.framework))) {
+    console.error(`  ${framework}: ${entries.filter((e) => e.framework === framework).length}`);
+}

package/dist/build-static-utils-index.js

@@ -0,0 +1,12 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseDocPage } from "./lib/docPageParser.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const srcPath = path.resolve(__dirname, "../vendor/docs/DataGrid-StaticUtils.html");
+const outPath = path.resolve(__dirname, "../data/static-utils-index.json");
+const html = fs.readFileSync(srcPath, "utf-8");
+const entries = parseDocPage(html);
+fs.mkdirSync(path.dirname(outPath), { recursive: true });
+fs.writeFileSync(outPath, JSON.stringify(entries, null, 2), "utf-8");
+console.error(`Wrote ${entries.length} static util entries to ${outPath}`);

package/dist/enrich-api-index.js

@@ -0,0 +1,50 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseDocPage } from "./lib/docPageParser.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const vendorDocs = path.resolve(__dirname, "../vendor/docs");
+const apiIndexPath = path.resolve(__dirname, "../data/api-index.json");
+const entries = JSON.parse(fs.readFileSync(apiIndexPath, "utf-8"));
+function applyEnrichment(doc, match) {
+    const target = entries.find(match);
+    if (!target)
+        return false;
+    if (doc.description)
+        target.officialDescription = doc.description;
+    if (doc.example)
+        target.example = doc.example;
+    return true;
+}
+// Properties.html: ids are the exact grid-option prop names (Props interface).
+const propertiesHtml = fs.readFileSync(path.join(vendorDocs, "DataGrid-Properties.html"), "utf-8");
+const propertyDocs = parseDocPage(propertiesHtml);
+let propMatched = 0;
+for (const doc of propertyDocs) {
+    if (applyEnrichment(doc, (e) => e.kind === "prop" && e.name === doc.name))
+        propMatched++;
+}
+// Events.html: ids are camelCase event names (e.g. "cellClick"), which map to
+// PascalCase "<Name>Event" interfaces in the .d.ts (e.g. "CellClickEvent").
+// A couple of event names diverge between the doc site and the .d.ts itself
+// (abbreviations, missing "Event" suffix) — handled as explicit aliases.
+const EVENT_NAME_ALIASES = {
+    rowAllCheckClick: "RowAllChkClickEvent",
+    // RowNumHeaderClick's own .d.ts interface is missing the usual "Event" suffix
+    // (upstream inconsistency), so it was classified as kind "other" rather than "event".
+    rowNumHeaderClick: "RowNumHeaderClick",
+};
+const eventsHtml = fs.readFileSync(path.join(vendorDocs, "DataGrid-Events.html"), "utf-8");
+const eventDocs = parseDocPage(eventsHtml);
+let eventMatched = 0;
+for (const doc of eventDocs) {
+    const pascalName = doc.name[0].toUpperCase() + doc.name.slice(1);
+    const ifaceName = EVENT_NAME_ALIASES[doc.name] ?? `${pascalName}Event`;
+    if (applyEnrichment(doc, (e) => (e.kind === "event" || e.kind === "other") && e.name === ifaceName))
+        eventMatched++;
+    else
+        console.error(`  no .d.ts match for event "${doc.name}" (tried "${ifaceName}")`);
+}
+fs.writeFileSync(apiIndexPath, JSON.stringify(entries, null, 2), "utf-8");
+console.error(`Enriched ${propMatched}/${propertyDocs.length} props from Properties.html`);
+console.error(`Enriched ${eventMatched}/${eventDocs.length} events from Events.html`);

package/dist/index.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { searchEntries, getEntry } from "./lib/apiIndex.js";
+import { searchSamples, getSample, listSamples } from "./lib/samplesIndex.js";
+import { searchMethods, getMethod } from "./lib/methodsIndex.js";
+import { searchStaticUtils, getStaticUtil } from "./lib/staticUtilsIndex.js";
+const server = new McpServer({
+    name: "auigrid-mcp-server",
+    version: "0.1.0",
+});
+server.registerTool("ping", {
+    title: "Ping",
+    description: "Health check — returns pong if the server is running.",
+    inputSchema: {},
+}, async () => ({
+    content: [{ type: "text", text: "pong" }],
+}));
+function formatEntry(e) {
+    const lines = [`### ${e.name}${e.parent ? ` (${e.parent})` : ""} [${e.kind}]`];
+    if (e.type)
+        lines.push(`type: ${e.type}`);
+    if (e.optional !== undefined)
+        lines.push(`optional: ${e.optional}`);
+    if (e.defaultValue !== undefined)
+        lines.push(`default: ${e.defaultValue}`);
+    if (e.description)
+        lines.push("", e.description);
+    if (e.officialDescription && e.officialDescription !== e.description) {
+        lines.push("", "Official docs (auisoft.net):", e.officialDescription);
+    }
+    if (e.example)
+        lines.push("", "Example:", "```javascript", e.example, "```");
+    return lines.join("\n");
+}
+const KIND_VALUES = [
+    "grid-option",
+    "prop",
+    "column",
+    "column-prop",
+    "renderer",
+    "renderer-prop",
+    "footer",
+    "footer-prop",
+    "event",
+    "event-prop",
+    "enum",
+    "enum-member",
+    "other",
+    "other-prop",
+];
+server.registerTool("search_api", {
+    title: "Search AUIGrid API",
+    description: "Search the AUIGrid API reference (grid options/props, Column fields, cell/edit/header renderers, events, enums) by keyword. Matches against name, parent interface, and Korean description text.",
+    inputSchema: {
+        query: z.string().describe("Keyword to search for, e.g. 'rowHeight', 'tree grid', 'CalendarRenderer'"),
+        kind: z.enum(KIND_VALUES).optional().describe("Restrict results to one entry kind"),
+        limit: z.number().int().min(1).max(50).optional().describe("Max results to return (default 15)"),
+    },
+}, async ({ query, kind, limit }) => {
+    const results = searchEntries(query, kind, limit ?? 15);
+    if (results.length === 0) {
+        return { content: [{ type: "text", text: `No matches for "${query}".` }] };
+    }
+    return {
+        content: [{ type: "text", text: results.map(formatEntry).join("\n\n---\n\n") }],
+    };
+});
+server.registerTool("get_api_entry", {
+    title: "Get AUIGrid API entry",
+    description: "Look up an exact AUIGrid API entry by name (a Props/Column field, renderer property, event property, enum member, etc). Optionally disambiguate by parent interface name when the same field name appears under multiple renderers/events.",
+    inputSchema: {
+        name: z.string().describe("Exact identifier, e.g. 'rowHeight' or 'onlyMonthMode'"),
+        parent: z
+            .string()
+            .optional()
+            .describe("Parent interface to disambiguate, e.g. 'CalendarRenderer'"),
+    },
+}, async ({ name, parent }) => {
+    const results = getEntry(name, parent);
+    if (results.length === 0) {
+        return { content: [{ type: "text", text: `No entry found for "${name}".` }] };
+    }
+    return {
+        content: [{ type: "text", text: results.map(formatEntry).join("\n\n---\n\n") }],
+    };
+});
+server.registerTool("search_samples", {
+    title: "Search AUIGrid samples",
+    description: "Full-text search over real AUIGrid React/TSX sample and showcase source files (e.g. tree grid, custom editors, drag & drop, export). Returns a matching code snippet from each hit — use get_sample to fetch the full file.",
+    inputSchema: {
+        query: z.string().describe("Keyword or feature to search for, e.g. 'tree grid', 'dropdown', 'export'"),
+        limit: z.number().int().min(1).max(30).optional().describe("Max results to return (default 10)"),
+    },
+}, async ({ query, limit }) => {
+    const results = searchSamples(query, limit ?? 10);
+    if (results.length === 0) {
+        return { content: [{ type: "text", text: `No sample matches for "${query}".` }] };
+    }
+    const text = results
+        .map((r) => `### ${r.name} (${r.framework}/${r.relPath})\n\`\`\`tsx\n${r.snippet}\n\`\`\``)
+        .join("\n\n---\n\n");
+    return { content: [{ type: "text", text }] };
+});
+server.registerTool("get_sample", {
+    title: "Get AUIGrid sample source",
+    description: "Fetch the full source of an AUIGrid sample or showcase file by exact name (e.g. 'SampleTreeGrid', 'EditDropDown', 'Showcase03').",
+    inputSchema: {
+        name: z.string().describe("Exact sample/showcase file name, e.g. 'SampleTreeGrid'"),
+    },
+}, async ({ name }) => {
+    const results = getSample(name);
+    if (results.length === 0) {
+        return { content: [{ type: "text", text: `No sample found named "${name}".` }] };
+    }
+    const text = results
+        .map((r) => `### ${r.name} (${r.framework}/${r.relPath})\n\`\`\`tsx\n${r.content}\n\`\`\``)
+        .join("\n\n---\n\n");
+    return { content: [{ type: "text", text }] };
+});
+server.registerTool("list_samples", {
+    title: "List AUIGrid samples",
+    description: "List all indexed AUIGrid sample/showcase file names, grouped by category.",
+    inputSchema: {},
+}, async () => {
+    const all = listSamples();
+    const byCategory = new Map();
+    for (const s of all) {
+        const list = byCategory.get(s.category) ?? [];
+        list.push(s.name);
+        byCategory.set(s.category, list);
+    }
+    const text = [...byCategory.entries()]
+        .map(([cat, names]) => `${cat}:\n  ${names.join(", ")}`)
+        .join("\n\n");
+    return { content: [{ type: "text", text }] };
+});
+function formatParam(p, indent = "") {
+    const lines = [`${indent}- ${p.name}${p.type ? ` (${p.type})` : ""}: ${p.description}`];
+    if (p.subParameters?.length) {
+        for (const sub of p.subParameters)
+            lines.push(...formatParam(sub, indent + "  "));
+    }
+    return lines;
+}
+function formatMethod(m) {
+    const lines = [`### ${m.name}()${m.version ? ` [since v${m.version}]` : ""}`];
+    if (m.description)
+        lines.push("", m.description);
+    if (m.parameters.length) {
+        lines.push("", "Parameters:", ...m.parameters.flatMap((p) => formatParam(p)));
+    }
+    if (m.example)
+        lines.push("", "Example:", "```javascript", m.example, "```");
+    if (m.notes)
+        lines.push("", m.notes);
+    return lines.join("\n");
+}
+server.registerTool("search_methods", {
+    title: "Search AUIGrid instance methods",
+    description: "Search the AUIGrid imperative instance-method API (e.g. AUIGrid.setGridData(gridId, data), insertRow, getRowById) by keyword. Sourced from the official auisoft.net method reference — covers methods not present in the React/Vue prop typings.",
+    inputSchema: {
+        query: z.string().describe("Keyword to search for, e.g. 'insertRow', 'export', 'grouping'"),
+        limit: z.number().int().min(1).max(50).optional().describe("Max results to return (default 15)"),
+    },
+}, async ({ query, limit }) => {
+    const results = searchMethods(query, limit ?? 15);
+    if (results.length === 0) {
+        return { content: [{ type: "text", text: `No method matches for "${query}".` }] };
+    }
+    return {
+        content: [{ type: "text", text: results.map(formatMethod).join("\n\n---\n\n") }],
+    };
+});
+server.registerTool("get_method", {
+    title: "Get AUIGrid instance method",
+    description: "Look up the full reference (description, parameters, example code) for an exact AUIGrid instance method name, e.g. 'setGridData' or 'insertRow'.",
+    inputSchema: {
+        name: z.string().describe("Exact method name, e.g. 'setGridData'"),
+    },
+}, async ({ name }) => {
+    const result = getMethod(name);
+    if (!result) {
+        return { content: [{ type: "text", text: `No method found named "${name}".` }] };
+    }
+    return { content: [{ type: "text", text: formatMethod(result) }] };
+});
+server.registerTool("search_static_utils", {
+    title: "Search AUIGrid static utilities",
+    description: "Search AUIGrid's static (non-instance) utility functions, e.g. AUIGrid.create(), formatDate(), formatNumber(), getActiveGrid(), isCreated(). These are called on the AUIGrid namespace itself, not a specific grid instance.",
+    inputSchema: {
+        query: z.string().describe("Keyword to search for, e.g. 'formatDate', 'create'"),
+        limit: z.number().int().min(1).max(50).optional().describe("Max results to return (default 15)"),
+    },
+}, async ({ query, limit }) => {
+    const results = searchStaticUtils(query, limit ?? 15);
+    if (results.length === 0) {
+        return { content: [{ type: "text", text: `No static util matches for "${query}".` }] };
+    }
+    return {
+        content: [{ type: "text", text: results.map(formatMethod).join("\n\n---\n\n") }],
+    };
+});
+server.registerTool("get_static_util", {
+    title: "Get AUIGrid static utility",
+    description: "Look up the full reference for an exact AUIGrid static utility name, e.g. 'formatDate'.",
+    inputSchema: {
+        name: z.string().describe("Exact static utility name, e.g. 'formatDate'"),
+    },
+}, async ({ name }) => {
+    const result = getStaticUtil(name);
+    if (!result) {
+        return { content: [{ type: "text", text: `No static util found named "${name}".` }] };
+    }
+    return { content: [{ type: "text", text: formatMethod(result) }] };
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("auigrid-mcp-server running on stdio");
+}
+main().catch((err) => {
+    console.error("Fatal error starting auigrid-mcp-server:", err);
+    process.exit(1);
+});

package/dist/lib/apiIndex.js

@@ -0,0 +1,40 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const indexPath = path.resolve(__dirname, "../../data/api-index.json");
+let entries = [];
+try {
+    entries = JSON.parse(fs.readFileSync(indexPath, "utf-8"));
+}
+catch (err) {
+    console.error(`Failed to load API index at ${indexPath}. Run "npm run build:index" first.`, err);
+}
+export function getEntries() {
+    return entries;
+}
+export function searchEntries(query, kind, limit = 15) {
+    const q = query.toLowerCase();
+    const results = entries.filter((e) => {
+        if (kind && e.kind !== kind)
+            return false;
+        return (e.name.toLowerCase().includes(q) ||
+            (e.parent?.toLowerCase().includes(q) ?? false) ||
+            e.description.toLowerCase().includes(q));
+    });
+    // Exact name matches first, then by whether the query matched the name at all,
+    // so a search like "rowHeight" surfaces the property before unrelated description hits.
+    results.sort((a, b) => {
+        const aExact = a.name.toLowerCase() === q ? 0 : 1;
+        const bExact = b.name.toLowerCase() === q ? 0 : 1;
+        if (aExact !== bExact)
+            return aExact - bExact;
+        const aNameHit = a.name.toLowerCase().includes(q) ? 0 : 1;
+        const bNameHit = b.name.toLowerCase().includes(q) ? 0 : 1;
+        return aNameHit - bNameHit;
+    });
+    return results.slice(0, limit);
+}
+export function getEntry(name, parent) {
+    return entries.filter((e) => e.name === name && (!parent || e.parent === parent));
+}

package/dist/lib/docPageParser.js

@@ -0,0 +1,101 @@
+import * as cheerio from "cheerio";
+function parseParamLi(text) {
+    const m = text.match(/^([^\s(]+)\s*\(([^)]*)\)\s*:\s*([\s\S]*)$/);
+    if (m) {
+        return { name: m[1].trim(), type: m[2].trim(), description: m[3].trim() };
+    }
+    return { name: "", description: text.trim() };
+}
+/**
+ * Parses the auisoft.net "summary table" doc page format shared by
+ * DataGrid/Methods.html, Properties.html, Events.html, StaticUtils.html:
+ * one <tr id="name"> per entry, full description/params/example inline
+ * in a single td.summaryTableDescription cell (no separate detail page).
+ */
+export function parseDocPage(html) {
+    const $ = cheerio.load(html);
+    const entries = [];
+    $("tr[id]").each((_, tr) => {
+        const $tr = $(tr);
+        const name = $tr.attr("id");
+        if (!name)
+            return;
+        const cell = $tr.find("td.summaryTableDescription").first();
+        if (cell.length === 0)
+            return;
+        const versionMatch = cell.text().match(/Version\s*:\s*([\d.]+)/);
+        const version = versionMatch?.[1];
+        const descParts = [];
+        const notesParts = [];
+        const parameters = [];
+        let example;
+        let phase = "description";
+        let pendingSubParamTarget = null;
+        cell.contents().each((_, node) => {
+            const el = $(node);
+            const tag = node.tagName?.toLowerCase();
+            if (tag === "p") {
+                const text = el.text().trim();
+                if (!text)
+                    return;
+                if (text === "파라메터 설명" || text === "파라미터 설명") {
+                    phase = "params";
+                    return;
+                }
+                const subHeader = text.match(/^■\s*(.+?)\s*파라(?:메터|미터)\s*설명\s*■$/);
+                if (subHeader) {
+                    pendingSubParamTarget = subHeader[1].trim();
+                    return;
+                }
+                if (phase === "description")
+                    descParts.push(text);
+                else
+                    notesParts.push(text);
+            }
+            else if (tag === "ul") {
+                if (phase === "params") {
+                    el.find("li").each((_, li) => {
+                        parameters.push(parseParamLi($(li).text().trim()));
+                    });
+                    phase = "notes";
+                }
+                else if (pendingSubParamTarget) {
+                    const subParams = el
+                        .find("li")
+                        .toArray()
+                        .map((li) => parseParamLi($(li).text().trim()));
+                    const target = parameters.find((p) => p.name.toLowerCase() === pendingSubParamTarget.toLowerCase());
+                    if (target) {
+                        target.subParameters = subParams;
+                    }
+                    else {
+                        parameters.push({
+                            name: pendingSubParamTarget,
+                            description: "(object properties)",
+                            subParameters: subParams,
+                        });
+                    }
+                    pendingSubParamTarget = null;
+                }
+                else {
+                    el.find("li").each((_, li) => {
+                        notesParts.push(`- ${$(li).text().trim()}`);
+                    });
+                }
+            }
+            else if (tag === "pre") {
+                const code = el.find("code").first().text() || el.text();
+                example = example ? `${example}\n\n${code.trim()}` : code.trim();
+            }
+        });
+        entries.push({
+            name,
+            version,
+            description: descParts.join("\n"),
+            parameters,
+            notes: notesParts.length ? notesParts.join("\n") : undefined,
+            example,
+        });
+    });
+    return entries;
+}

package/dist/lib/methodsIndex.js

@@ -0,0 +1,32 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const indexPath = path.resolve(__dirname, "../../data/methods-index.json");
+let entries = [];
+try {
+    entries = JSON.parse(fs.readFileSync(indexPath, "utf-8"));
+}
+catch (err) {
+    console.error(`Failed to load methods index at ${indexPath}. Run "npm run build:methods-index" first.`, err);
+}
+export function searchMethods(query, limit = 15) {
+    const q = query.toLowerCase();
+    const results = entries.filter((e) => e.name.toLowerCase().includes(q) ||
+        e.description.toLowerCase().includes(q) ||
+        e.parameters.some((p) => p.name.toLowerCase().includes(q)));
+    results.sort((a, b) => {
+        const aExact = a.name.toLowerCase() === q ? 0 : 1;
+        const bExact = b.name.toLowerCase() === q ? 0 : 1;
+        if (aExact !== bExact)
+            return aExact - bExact;
+        const aNameHit = a.name.toLowerCase().includes(q) ? 0 : 1;
+        const bNameHit = b.name.toLowerCase().includes(q) ? 0 : 1;
+        return aNameHit - bNameHit;
+    });
+    return results.slice(0, limit);
+}
+export function getMethod(name) {
+    const lower = name.toLowerCase();
+    return entries.find((e) => e.name.toLowerCase() === lower);
+}

package/dist/lib/samplesIndex.js

@@ -0,0 +1,52 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const indexPath = path.resolve(__dirname, "../../data/samples-index.json");
+let entries = [];
+try {
+    entries = JSON.parse(fs.readFileSync(indexPath, "utf-8"));
+}
+catch (err) {
+    console.error(`Failed to load samples index at ${indexPath}. Run "npm run build:samples-index" first.`, err);
+}
+function snippetAround(content, query, contextLines = 3) {
+    const lines = content.split("\n");
+    const q = query.toLowerCase();
+    const hitIdx = lines.findIndex((l) => l.toLowerCase().includes(q));
+    if (hitIdx === -1)
+        return lines.slice(0, contextLines * 2).join("\n");
+    const start = Math.max(0, hitIdx - contextLines);
+    const end = Math.min(lines.length, hitIdx + contextLines + 1);
+    return lines.slice(start, end).join("\n");
+}
+export function searchSamples(query, limit = 10) {
+    const q = query.toLowerCase();
+    const matches = entries.filter((e) => e.name.toLowerCase().includes(q) ||
+        e.category.toLowerCase().includes(q) ||
+        e.content.toLowerCase().includes(q));
+    matches.sort((a, b) => {
+        const aNameHit = a.name.toLowerCase().includes(q) ? 0 : 1;
+        const bNameHit = b.name.toLowerCase().includes(q) ? 0 : 1;
+        return aNameHit - bNameHit;
+    });
+    return matches.slice(0, limit).map((e) => ({
+        name: e.name,
+        framework: e.framework,
+        category: e.category,
+        relPath: e.relPath,
+        snippet: snippetAround(e.content, query),
+    }));
+}
+export function getSample(name) {
+    const lower = name.toLowerCase();
+    return entries.filter((e) => e.name.toLowerCase() === lower);
+}
+export function listSamples() {
+    return entries.map(({ name, framework, category, relPath }) => ({
+        name,
+        framework,
+        category,
+        relPath,
+    }));
+}