@rfdtech/components 1.22.0 → 2.0.1

package/dist/mcp/cli.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import { loadIndex, searchComponents } from "./docs.js";
+import { runDoctor } from "./installers/doctor.js";
+import { runSetup } from "./installers/setup.js";
+import { buildIndex } from "./indexer.js";
+import { GENERATED_DIR, hasRepoSource } from "./paths.js";
+const USAGE = `rfdui — @rfdtech/components AI tooling
+
+Usage:
+  rfdui setup           Detect installed AI tools (Claude Code, Cursor, Codex, OpenCode) and wire up
+                         the MCP server + a shared skill doc for each.
+  rfdui doctor           Report whether the index, MCP, and each AI tool are configured correctly.
+  rfdui index            Rebuild the generated docs index (only works inside the repo checkout).
+  rfdui mcp              Run the MCP server directly over stdio.
+  rfdui search <query>   Lexical search over components from the terminal.
+  rfdui update           Rebuild the index (if possible) and re-run setup.
+`;
+async function main() {
+    const [, , cmd, ...rest] = process.argv;
+    switch (cmd) {
+        case "index": {
+            if (!hasRepoSource) {
+                console.error("`rfdui index` only works inside the gsl-components repo checkout (no source found).");
+                process.exitCode = 1;
+                return;
+            }
+            const result = await buildIndex(GENERATED_DIR);
+            console.log(`Index built: ${JSON.stringify(result, null, 2)}`);
+            return;
+        }
+        case "search": {
+            const query = rest.join(" ").trim();
+            if (!query) {
+                console.error("Usage: rfdui search <query>");
+                process.exitCode = 1;
+                return;
+            }
+            const idx = await loadIndex();
+            const results = searchComponents(idx, query);
+            if (results.length === 0) {
+                console.log(`No components matched "${query}".`);
+                return;
+            }
+            for (const r of results) {
+                console.log(`${r.slug.padEnd(24)} ${r.name}${r.description ? ` — ${r.description}` : ""}`);
+            }
+            return;
+        }
+        case "doctor":
+            await runDoctor();
+            return;
+        case "setup":
+            await runSetup();
+            return;
+        case "update":
+            if (hasRepoSource) {
+                const result = await buildIndex(GENERATED_DIR);
+                console.log(`Index rebuilt: ${JSON.stringify(result)}`);
+            }
+            await runSetup();
+            return;
+        case "mcp":
+            // Delegate to the server entry point (same process, same stdio streams).
+            await import("./index.js");
+            return;
+        default:
+            console.log(USAGE);
+            if (cmd && cmd !== "help" && cmd !== "--help")
+                process.exitCode = 1;
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exitCode = 1;
+});

package/dist/mcp/docs.js

@@ -0,0 +1,122 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { GENERATED_DIR } from "./paths.js";
+async function readJson(name) {
+    const raw = await readFile(path.join(GENERATED_DIR, name), "utf8");
+    return JSON.parse(raw);
+}
+export async function loadIndex() {
+    const [components, search, rules, tokens, examples] = await Promise.all([
+        readJson("components.json"),
+        readJson("search.json"),
+        readJson("rules.json"),
+        readJson("tokens.json"),
+        readJson("examples.json"),
+    ]);
+    const rulesById = {};
+    for (const category of Object.values(rules)) {
+        for (const rule of category)
+            rulesById[rule.id] = rule;
+    }
+    return { components, search, rules, rulesById, tokens, examples };
+}
+export function listSlugs(idx) {
+    return Object.keys(idx.components).sort();
+}
+export function getComponent(idx, slug) {
+    return idx.components[slug.trim().toLowerCase()] ?? null;
+}
+/**
+ * Lexical ranking over name/slug/keywords/description/headings. No embeddings —
+ * this is a local, offline MCP server; ranking is transparent term overlap, not
+ * semantic similarity. Good enough for "table pagination" -> Table, "wizard" ->
+ * Stepper (via keywords), etc.
+ */
+export function searchComponents(idx, query, limit = 8) {
+    const terms = query.toLowerCase().trim().split(/\s+/).filter(Boolean);
+    if (terms.length === 0)
+        return [];
+    const scored = idx.search.map((entry) => {
+        const slug = entry.slug.toLowerCase();
+        const name = (entry.name ?? "").toLowerCase();
+        const keywords = (entry.keywords ?? []).map((k) => k.toLowerCase());
+        const description = (entry.description ?? "").toLowerCase();
+        const headings = (entry.headings ?? []).map((h) => h.toLowerCase());
+        let score = 0;
+        for (const term of terms) {
+            if (slug === term)
+                score += 10;
+            if (slug.includes(term))
+                score += 5;
+            if (name.includes(term))
+                score += 4;
+            if (keywords.some((k) => k.includes(term)))
+                score += 3;
+            if (description.includes(term))
+                score += 2;
+            if (headings.some((h) => h.includes(term)))
+                score += 1;
+        }
+        return { entry, score };
+    });
+    return scored
+        .filter((r) => r.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit)
+        .map((r) => ({
+        slug: r.entry.slug,
+        name: r.entry.name,
+        category: r.entry.category,
+        description: r.entry.description,
+        score: r.score,
+    }));
+}
+export function searchDocs(idx, query, limit = 8) {
+    const terms = query.toLowerCase().trim().split(/\s+/).filter(Boolean);
+    if (terms.length === 0)
+        return [];
+    const results = Object.values(idx.components).map((entry) => {
+        const body = entry.docs.toLowerCase();
+        const matchedHeadings = entry.headings.filter((h) => terms.some((t) => h.toLowerCase().includes(t)));
+        let score = 0;
+        for (const term of terms) {
+            if (body.includes(term))
+                score += 2;
+        }
+        score += matchedHeadings.length;
+        return { slug: entry.meta.slug, name: entry.meta.title, matchedHeadings, score };
+    });
+    return results
+        .filter((r) => r.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+}
+/** `topic` may be a rules category (e.g. "forms") or a component slug (e.g. "dialog"). */
+export function getRules(idx, topic) {
+    if (!topic)
+        return idx.rules;
+    const key = topic.trim().toLowerCase();
+    if (idx.rules[key])
+        return { [key]: idx.rules[key] };
+    const matched = [];
+    for (const rules of Object.values(idx.rules)) {
+        matched.push(...rules.filter((r) => r.components.includes(key)));
+    }
+    return matched.length ? { [key]: matched } : {};
+}
+export function searchRules(idx, query, limit = 10) {
+    const terms = query.toLowerCase().trim().split(/\s+/).filter(Boolean);
+    if (terms.length === 0)
+        return [];
+    const all = Object.values(idx.rules).flat();
+    const scored = all.map((rule) => {
+        const hay = `${rule.title} ${rule.body} ${rule.components.join(" ")}`.toLowerCase();
+        const score = terms.reduce((n, t) => n + (hay.includes(t) ? 1 : 0), 0);
+        return { rule, score };
+    });
+    return scored
+        .filter((r) => r.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit)
+        .map((r) => r.rule);
+}