@smwb/ui-mcp-solid 0.1.0

package/componentMeta.mjs

@@ -0,0 +1,493 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const META_FILE_PATTERN = /\.json$/;
+const SKIP_META_FILES = /\.mock\.json$/;
+
+const QUERY_ALIASES = {
+  btn: "button",
+  btns: "button",
+  msg: "message",
+  msgs: "message",
+  txt: "text",
+  fld: "field",
+  nav: "navigation",
+  dlg: "dialog",
+  modal: "dialog",
+  dropdown: "select",
+  picker: "date",
+  avatar: "avatar",
+  tbl: "table",
+  pag: "pagination",
+  snack: "snackbar",
+  tooltip: "tooltip",
+};
+
+export function isComponentMetaFile(fileName) {
+  return META_FILE_PATTERN.test(fileName) && !SKIP_META_FILES.test(fileName) && fileName !== "manifest.json";
+}
+
+export function walkMetaFiles(rootDir, files = [], relativeRoot = rootDir) {
+  if (!fs.existsSync(rootDir)) {
+    return files;
+  }
+
+  for (const entry of fs.readdirSync(rootDir, { withFileTypes: true })) {
+    const fullPath = path.join(rootDir, entry.name);
+    if (entry.isDirectory()) {
+      walkMetaFiles(fullPath, files, relativeRoot);
+      continue;
+    }
+    if (!entry.isFile() || !isComponentMetaFile(entry.name)) {
+      continue;
+    }
+    files.push({
+      absolutePath: fullPath,
+      relativePath: path.relative(relativeRoot, fullPath).replace(/\\/g, "/"),
+    });
+  }
+
+  return files;
+}
+
+export function toComponentId(relativePath) {
+  return relativePath.replace(/\.json$/, "");
+}
+
+export function normalizeText(value) {
+  return String(value ?? "")
+    .trim()
+    .toLowerCase()
+    .normalize("NFKD")
+    .replace(/[\u0300-\u036f]/g, "");
+}
+
+export function compactText(value) {
+  return normalizeText(value).replace(/[^a-z0-9]+/g, "");
+}
+
+export function splitCamelCase(value) {
+  return String(value ?? "")
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+    .toLowerCase()
+    .split(/[^a-z0-9]+/g)
+    .filter(Boolean);
+}
+
+export function tokenize(value) {
+  const parts = String(value ?? "")
+    .trim()
+    .split(/[^a-zA-Z0-9]+/g)
+    .filter(Boolean);
+  const expanded = [];
+
+  for (const part of parts) {
+    const camelParts = splitCamelCase(part);
+    const tokens = camelParts.length ? camelParts : [normalizeText(part)];
+
+    for (const token of tokens) {
+      if (!token) {
+        continue;
+      }
+      expanded.push(token);
+      if (QUERY_ALIASES[token]) {
+        expanded.push(QUERY_ALIASES[token]);
+      }
+    }
+  }
+
+  return [...new Set(expanded.filter(Boolean))];
+}
+
+export function levenshtein(a, b) {
+  if (a === b) {
+    return 0;
+  }
+  if (!a.length) {
+    return b.length;
+  }
+  if (!b.length) {
+    return a.length;
+  }
+
+  const rows = b.length + 1;
+  const cols = a.length + 1;
+  const matrix = Array.from({ length: rows }, () => Array(cols).fill(0));
+
+  for (let i = 0; i < rows; i += 1) {
+    matrix[i][0] = i;
+  }
+  for (let j = 0; j < cols; j += 1) {
+    matrix[0][j] = j;
+  }
+
+  for (let i = 1; i < rows; i += 1) {
+    for (let j = 1; j < cols; j += 1) {
+      const cost = b.charCodeAt(i - 1) === a.charCodeAt(j - 1) ? 0 : 1;
+      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
+    }
+  }
+
+  return matrix[rows - 1][cols - 1];
+}
+
+export function similarityScore(a, b) {
+  const left = compactText(a);
+  const right = compactText(b);
+  const maxLen = Math.max(left.length, right.length);
+  if (!maxLen) {
+    return 1;
+  }
+  return 1 - levenshtein(left, right) / maxLen;
+}
+
+function buildSearchProfile(entry) {
+  const idSegments = entry.id.split("/").flatMap((segment) => tokenize(segment));
+  const nameTokens = splitCamelCase(entry.name);
+  const descriptionTokens = tokenize(entry.description);
+  const propTokens = entry.propNames.flatMap((name) => tokenize(name));
+
+  return {
+    name: normalizeText(entry.name),
+    nameCompact: compactText(entry.name),
+    id: normalizeText(entry.id),
+    idCompact: compactText(entry.id),
+    idSegments: [...new Set(idSegments)],
+    nameTokens: [...new Set(nameTokens)],
+    description: normalizeText(entry.description),
+    descriptionTokens: [...new Set(descriptionTokens)],
+    propTokens: [...new Set(propTokens)],
+    allTokens: [...new Set([...nameTokens, ...idSegments, ...descriptionTokens, ...propTokens])],
+  };
+}
+
+function acronymMatches(tokens, queryCompact) {
+  if (!queryCompact || queryCompact.length < 2) {
+    return false;
+  }
+  const acronym = tokens.map((token) => token[0]).join("");
+  return acronym.startsWith(queryCompact) || queryCompact.startsWith(acronym);
+}
+
+function countTokenMatches(tokens, queryTokens) {
+  let matched = 0;
+  for (const queryToken of queryTokens) {
+    if (tokens.some((token) => token === queryToken || token.startsWith(queryToken) || queryToken.startsWith(token))) {
+      matched += 1;
+    }
+  }
+  return matched;
+}
+
+function scoreComponent(entry, query, queryTokens, queryCompact) {
+  const profile = entry.searchProfile;
+  let score = 0;
+  const reasons = [];
+
+  if (profile.name === query) {
+    score += 1000;
+    reasons.push("exact-name");
+  }
+  if (profile.id === query || profile.id.endsWith(`/${query}`)) {
+    score += 950;
+    reasons.push("exact-id");
+  }
+  if (profile.nameCompact === queryCompact) {
+    score += 900;
+    reasons.push("compact-name");
+  }
+  if (profile.name.startsWith(query)) {
+    score += 700;
+    reasons.push("name-prefix");
+  }
+  if (profile.name.includes(query)) {
+    score += 520;
+    reasons.push("name-substring");
+  }
+  if (profile.id.includes(query)) {
+    score += 480;
+    reasons.push("id-substring");
+  }
+  if (profile.description.includes(query)) {
+    score += queryTokens.length > 1 ? 420 : 210;
+    reasons.push("description-phrase");
+  }
+
+  const nameTokenMatches = countTokenMatches(profile.nameTokens, queryTokens);
+  if (queryTokens.length && nameTokenMatches === queryTokens.length) {
+    score += 360 + nameTokenMatches * 40;
+    reasons.push("all-name-tokens");
+  } else {
+    score += nameTokenMatches * 70;
+    if (nameTokenMatches) {
+      reasons.push("name-token");
+    }
+  }
+
+  const idTokenMatches = countTokenMatches(profile.idSegments, queryTokens);
+  score += idTokenMatches * 55;
+  if (idTokenMatches) {
+    reasons.push("id-token");
+  }
+
+  const descriptionTokenMatches = countTokenMatches(profile.descriptionTokens, queryTokens);
+  score += descriptionTokenMatches * 45;
+  if (descriptionTokenMatches) {
+    reasons.push("description-token");
+  }
+
+  const propTokenMatches = countTokenMatches(profile.propTokens, queryTokens);
+  score += propTokenMatches * 35;
+  if (propTokenMatches) {
+    reasons.push("prop-token");
+  }
+
+  for (const queryToken of queryTokens) {
+    const exactProp = entry.propNames.find((prop) => normalizeText(prop) === queryToken);
+    if (exactProp) {
+      score += 340;
+      reasons.push("exact-prop-name");
+    }
+  }
+
+  if (queryTokens.length > 1) {
+    const allTokenMatches = countTokenMatches(profile.allTokens, queryTokens);
+    if (allTokenMatches === queryTokens.length) {
+      score += 180;
+      reasons.push("all-tokens");
+    }
+  }
+
+  if (acronymMatches(profile.nameTokens, queryCompact)) {
+    score += 260;
+    reasons.push("acronym");
+  }
+
+  const nameSimilarity = similarityScore(profile.nameCompact, queryCompact);
+  if (queryCompact.length >= 3 && nameSimilarity >= 0.72) {
+    score += Math.round(nameSimilarity * 280);
+    reasons.push("fuzzy-name");
+  }
+
+  const idSimilarity = similarityScore(profile.idCompact, queryCompact);
+  if (queryCompact.length >= 4 && idSimilarity >= 0.68) {
+    score += Math.round(idSimilarity * 180);
+    reasons.push("fuzzy-id");
+  }
+
+  for (const queryToken of queryTokens) {
+    if (queryToken.length < 3) {
+      continue;
+    }
+    for (const token of profile.nameTokens) {
+      if (token.startsWith(queryToken) || queryToken.startsWith(token)) {
+        score += 90;
+        reasons.push("token-prefix");
+        break;
+      }
+    }
+  }
+
+  return { score, reasons: [...new Set(reasons)] };
+}
+
+export function parseComponentMetaFile(absolutePath, relativePath) {
+  const raw = fs.readFileSync(absolutePath, "utf8");
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || typeof parsed.name !== "string") {
+    throw new Error(`Invalid component metadata file: ${relativePath}`);
+  }
+
+  const id = toComponentId(relativePath);
+  const propNames = parsed.props ? Object.keys(parsed.props) : [];
+
+  const entry = {
+    id,
+    name: parsed.name,
+    description: parsed.description ?? "",
+    extends: parsed.extends,
+    inheritedAttributes: parsed.inheritedAttributes,
+    styles: parsed.styles,
+    props: parsed.props ?? {},
+    propNames,
+    sourcePath: relativePath,
+  };
+
+  entry.searchProfile = buildSearchProfile(entry);
+  return entry;
+}
+
+export function loadComponentCatalog(metaRootDir) {
+  const files = walkMetaFiles(metaRootDir);
+  const byId = new Map();
+  const byName = new Map();
+  const all = [];
+
+  for (const file of files) {
+    const entry = parseComponentMetaFile(file.absolutePath, file.relativePath);
+    all.push(entry);
+    byId.set(normalizeText(entry.id), entry);
+    byName.set(normalizeText(entry.name), entry);
+  }
+
+  all.sort((a, b) => a.name.localeCompare(b.name));
+
+  return {
+    metaRootDir,
+    count: all.length,
+    all,
+    byId,
+    byName,
+  };
+}
+
+export function searchComponents(catalog, query, limit = 10) {
+  const normalizedQuery = normalizeText(query ?? "");
+  if (!normalizedQuery) {
+    return catalog.all.slice(0, limit).map((entry) => ({
+      id: entry.id,
+      name: entry.name,
+      description: entry.description,
+      propCount: entry.propNames.length,
+    }));
+  }
+
+  const queryTokens = tokenize(normalizedQuery);
+  const queryCompact = compactText(normalizedQuery);
+
+  return catalog.all
+    .map((entry) => {
+      const result = scoreComponent(entry, normalizedQuery, queryTokens, queryCompact);
+      return { entry, ...result };
+    })
+    .filter((item) => item.score >= 40)
+    .sort(
+      (a, b) =>
+        b.score - a.score ||
+        similarityScore(b.entry.name, normalizedQuery) - similarityScore(a.entry.name, normalizedQuery) ||
+        a.entry.name.localeCompare(b.entry.name)
+    )
+    .slice(0, limit)
+    .map(({ entry, score, reasons }) => ({
+      id: entry.id,
+      name: entry.name,
+      description: entry.description,
+      propCount: entry.propNames.length,
+      score,
+      matchReasons: reasons,
+    }));
+}
+
+export function resolveComponent(catalog, nameOrId) {
+  const key = normalizeText(nameOrId ?? "");
+  if (!key) {
+    return null;
+  }
+
+  const exact =
+    catalog.byId.get(key) ??
+    catalog.byName.get(key) ??
+    catalog.all.find((entry) => normalizeText(entry.name) === key) ??
+    null;
+
+  if (exact) {
+    return exact;
+  }
+
+  const [bestMatch] = searchComponents(catalog, key, 1);
+  if (!bestMatch || bestMatch.score < 120) {
+    return null;
+  }
+
+  return catalog.byId.get(normalizeText(bestMatch.id)) ?? catalog.all.find((entry) => entry.id === bestMatch.id) ?? null;
+}
+
+export function getComponentProps(catalog, nameOrId) {
+  const entry = resolveComponent(catalog, nameOrId);
+  if (!entry) {
+    return null;
+  }
+
+  return {
+    id: entry.id,
+    name: entry.name,
+    description: entry.description,
+    extends: entry.extends,
+    inheritedAttributes: entry.inheritedAttributes,
+    styles: entry.styles,
+    props: entry.props,
+    sourcePath: entry.sourcePath,
+  };
+}
+
+export function resolveMetaRootDirs(packageRoot) {
+  const candidates = [
+    path.join(packageRoot, "component-meta"),
+    path.join(packageRoot, "dist", "mcp", "component-meta"),
+    path.join(packageRoot, "mcp", "component-meta"),
+    path.join(packageRoot, "src", "components"),
+  ];
+
+  const roots = [];
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) {
+      continue;
+    }
+    if (candidate.endsWith(`${path.sep}components`)) {
+      roots.push({ dir: candidate, mode: "source-tree" });
+      roots.push({ dir: path.join(packageRoot, "src", "connects"), mode: "source-tree" });
+      break;
+    }
+    roots.push({ dir: candidate, mode: "bundle" });
+    break;
+  }
+
+  return roots;
+}
+
+export function loadCatalogFromPackageRoot(packageRoot) {
+  const roots = resolveMetaRootDirs(packageRoot);
+  if (!roots.length) {
+    throw new Error(`Component metadata directory was not found under ${packageRoot}`);
+  }
+
+  if (roots[0].mode === "bundle") {
+    return loadComponentCatalog(roots[0].dir);
+  }
+
+  const merged = [];
+  const byId = new Map();
+  const byName = new Map();
+
+  for (const root of roots) {
+    if (!fs.existsSync(root.dir)) {
+      continue;
+    }
+    const catalog = loadComponentCatalog(root.dir);
+    for (const entry of catalog.all) {
+      const prefixedId = root.dir.endsWith(`${path.sep}connects`)
+        ? `connects/${entry.id}`
+        : entry.id;
+      const normalized = {
+        ...entry,
+        id: prefixedId,
+        sourcePath: `${path.basename(root.dir)}/${entry.sourcePath}`,
+      };
+      normalized.searchProfile = buildSearchProfile(normalized);
+      merged.push(normalized);
+      byId.set(normalizeText(normalized.id), normalized);
+      byName.set(normalizeText(normalized.name), normalized);
+    }
+  }
+
+  merged.sort((a, b) => a.name.localeCompare(b.name));
+
+  return {
+    metaRootDir: packageRoot,
+    count: merged.length,
+    all: merged,
+    byId,
+    byName,
+  };
+}