simple-dynamsoft-mcp 4.0.0 → 6.2.0

package/src/resource-index/uri.js

@@ -0,0 +1,86 @@
+function parseResourceUri(uri) {
+  if (!uri || !uri.includes("://")) return null;
+  const [scheme, rest] = uri.split("://");
+  const parts = rest.split("/").filter(Boolean);
+  if (parts.length < 4) return { scheme, parts };
+  return {
+    scheme,
+    product: parts[0],
+    edition: parts[1],
+    platform: parts[2],
+    version: parts[3],
+    parts
+  };
+}
+
+function parseSampleUri(uri) {
+  const parsed = parseResourceUri(uri);
+  if (!parsed || parsed.scheme !== "sample" || !parsed.product) return null;
+
+  if (parsed.product === "dbr" && parsed.edition === "mobile") {
+    return {
+      product: "dbr",
+      edition: "mobile",
+      platform: parsed.platform,
+      version: parsed.version,
+      level: parsed.parts[4],
+      sampleName: parsed.parts[5]
+    };
+  }
+
+  if (parsed.product === "dbr" && parsed.edition === "web") {
+    return {
+      product: "dbr",
+      edition: "web",
+      platform: parsed.platform,
+      version: parsed.version,
+      category: parsed.parts[4],
+      sampleName: parsed.parts[5]
+    };
+  }
+
+  if (parsed.product === "dbr" && (parsed.edition === "python" || parsed.edition === "server")) {
+    return {
+      product: "dbr",
+      edition: parsed.edition,
+      platform: parsed.platform,
+      version: parsed.version,
+      sampleName: parsed.parts[4]
+    };
+  }
+
+  if (parsed.product === "dwt") {
+    return {
+      product: "dwt",
+      edition: parsed.edition,
+      platform: parsed.platform,
+      version: parsed.version,
+      category: parsed.parts[4],
+      sampleName: parsed.parts[5]
+    };
+  }
+
+  if (parsed.product === "ddv") {
+    return {
+      product: "ddv",
+      edition: parsed.edition,
+      platform: parsed.platform,
+      version: parsed.version,
+      sampleName: parsed.parts[4]
+    };
+  }
+
+  return null;
+}
+
+function getSampleIdFromUri(uri) {
+  const parsed = parseSampleUri(uri);
+  if (!parsed) return "";
+  return parsed.sampleName || "";
+}
+
+export {
+  parseResourceUri,
+  parseSampleUri,
+  getSampleIdFromUri
+};

package/src/resource-index/version-policy.js

@@ -0,0 +1,154 @@
+import { LEGACY_DBR_LINKS, LEGACY_DWT_LINKS } from "./config.js";
+import { inferProductFromQuery, normalizeEdition, normalizePlatform } from "../normalizers.js";
+
+function parseMajorVersion(version) {
+  if (!version) return null;
+  const match = String(version).match(/(\d+)/);
+  if (!match) return null;
+  return Number.parseInt(match[1], 10);
+}
+
+function detectMajorFromQuery(query) {
+  if (!query) return null;
+  const text = String(query);
+  const explicit = text.match(/(?:\bv|\bversion\s*)(\d{1,2})(?:\.\d+)?/i);
+  const productScoped = text.match(/(?:dbr|dwt|ddv)[^0-9]*(\d{1,2})(?:\.\d+)?/i);
+  const match = explicit || productScoped;
+  if (!match) return null;
+  const major = Number.parseInt(match[1], 10);
+  return Number.isNaN(major) ? null : major;
+}
+
+function formatLegacyLinksForDBR(major) {
+  const byMajor = LEGACY_DBR_LINKS[String(major)];
+  if (!byMajor) return `No legacy docs are available for DBR v${major}.`;
+
+  return [
+    `Legacy docs for DBR v${major}:`,
+    `- Web (JS): ${byMajor.web.web || "Not available"}`,
+    `- Server/Desktop (C++): ${byMajor.cpp.desktop || "Not available"}`,
+    `- Server/Desktop (Java): ${byMajor.java.desktop || "Not available"}`,
+    `- Server/Desktop (.NET): ${byMajor.dotnet.desktop || "Not available"}`,
+    `- Server/Desktop (Python): ${byMajor.python.desktop || "Not available"}`,
+    `- Mobile (Android): ${byMajor.mobile.android || "Not available"}`,
+    `- Mobile (iOS): ${byMajor.mobile.ios || "Not available"}`
+  ].join("\n");
+}
+
+function getLegacyLink(product, version, edition, platform) {
+  if (product === "dwt") {
+    if (!version) return null;
+    return LEGACY_DWT_LINKS[version] || null;
+  }
+
+  if (product !== "dbr") return null;
+  const major = parseMajorVersion(version);
+  if (!major) return null;
+
+  const byMajor = LEGACY_DBR_LINKS[String(major)];
+  if (!byMajor) return null;
+
+  const normalizedEdition = normalizeEdition(edition, platform, product) || "web";
+  const normalizedPlatform = normalizePlatform(platform);
+  if (normalizedEdition === "mobile") {
+    if (normalizedPlatform === "android") return byMajor.mobile.android;
+    if (normalizedPlatform === "ios") return byMajor.mobile.ios;
+    return null;
+  }
+  if (normalizedEdition === "web") return byMajor.web.web;
+  if (normalizedEdition === "server") {
+    if (normalizedPlatform === "python") return byMajor.python.desktop;
+    if (normalizedPlatform === "cpp") return byMajor.cpp.desktop;
+    if (normalizedPlatform === "java") return byMajor.java.desktop;
+    if (normalizedPlatform === "dotnet") return byMajor.dotnet.desktop;
+  }
+  return null;
+}
+
+function ensureLatestMajor({ product, version, query, edition, platform, latestMajor }) {
+  const inferredProduct = product || inferProductFromQuery(query);
+  if (!inferredProduct) return { ok: true };
+
+  const currentMajor = latestMajor[inferredProduct];
+  const requestedMajor = parseMajorVersion(version) ?? detectMajorFromQuery(query);
+
+  if (!requestedMajor || requestedMajor === currentMajor) {
+    return { ok: true, latestMajor: currentMajor };
+  }
+
+  if (inferredProduct === "ddv") {
+    return {
+      ok: false,
+      message: `This MCP server only serves the latest major version of DDV (v${currentMajor}).`
+    };
+  }
+
+  if (inferredProduct === "dbr" && requestedMajor < 9) {
+    return {
+      ok: false,
+      message: `This MCP server only serves the latest major version of DBR (v${currentMajor}). DBR versions prior to v9 are not available.`
+    };
+  }
+
+  if (inferredProduct === "dwt" && requestedMajor < 16) {
+    return {
+      ok: false,
+      message: `This MCP server only serves the latest major version of DWT (v${currentMajor}). DWT versions prior to v16 are not available.`
+    };
+  }
+
+  if (inferredProduct === "dbr") {
+    const link = getLegacyLink("dbr", String(requestedMajor), edition, platform);
+    const fallback = formatLegacyLinksForDBR(requestedMajor);
+    return {
+      ok: false,
+      message: [
+        `This MCP server only serves the latest major version of DBR (v${currentMajor}).`,
+        link ? `Legacy docs: ${link}` : fallback
+      ].join("\n")
+    };
+  }
+
+  if (inferredProduct === "dwt") {
+    const available = Object.keys(LEGACY_DWT_LINKS).sort();
+    const link = getLegacyLink("dwt", String(version), edition, platform);
+    const legacyNote = link ? `Legacy docs: ${link}` : `Available archived DWT versions: ${available.join(", ")}`;
+    return {
+      ok: false,
+      message: [
+        `This MCP server only serves the latest major version of DWT (v${currentMajor}).`,
+        legacyNote
+      ].join("\n")
+    };
+  }
+
+  return { ok: false, message: "Unsupported version request." };
+}
+
+function buildVersionPolicyText(latestMajor) {
+  const dwtLegacyVersions = Object.keys(LEGACY_DWT_LINKS).sort().join(", ");
+  return [
+    "# Version Policy",
+    "",
+    "This MCP server only serves the latest major versions of each product.",
+    "",
+    `- DBR latest major: v${latestMajor.dbr}`,
+    `- DWT latest major: v${latestMajor.dwt}`,
+    `- DDV latest major: v${latestMajor.ddv}`,
+    "",
+    "Legacy support:",
+    "- DBR v9 and v10 docs are linked when requested.",
+    `- DWT archived docs available: ${dwtLegacyVersions || "none"}.`,
+    "",
+    "Requests for older major versions are refused with a helpful message."
+  ].join("\n");
+}
+
+export {
+  parseMajorVersion,
+  detectMajorFromQuery,
+  formatLegacyLinksForDBR,
+  getLegacyLink,
+  ensureLatestMajor,
+  buildVersionPolicyText
+};

package/src/resource-index.js

@@ -0,0 +1,395 @@
+import { readFileSync } from "node:fs";
+import {
+  normalizeSdkId,
+  normalizePlatform,
+  normalizeLanguage,
+  normalizeApiLevel,
+  normalizeSampleName,
+  normalizeProduct,
+  normalizeEdition,
+  isServerPlatform,
+  isWebFrameworkPlatform,
+  isWebPlatform,
+  inferProductFromQuery,
+  WEB_FRAMEWORK_TAG_ALIASES,
+  setWebFrameworkPlatformsGetter
+} from "./normalizers.js";
+import { DOCS_CONFIG } from "./resource-index/config.js";
+import { loadMarkdownDocs } from "./resource-index/docs-loader.js";
+import { registryPath, DOC_ROOTS, SAMPLE_ROOTS, readSubmoduleHead } from "./resource-index/paths.js";
+import {
+  getCodeFileExtensions,
+  isCodeFile,
+  discoverMobileSamples,
+  discoverDbrServerSamples,
+  discoverPythonSamples,
+  discoverWebSamples,
+  getWebSamplePath,
+  discoverDwtSamples,
+  discoverDdvSamples,
+  mapDdvSampleToFramework,
+  getDbrWebFrameworkPlatforms,
+  getDdvWebFrameworkPlatforms,
+  getWebFrameworkPlatforms,
+  findCodeFilesInSample,
+  getDbrMobilePlatforms,
+  getDbrServerPlatforms,
+  getMobileSamplePath,
+  getPythonSamplePath,
+  getDbrServerSamplePath,
+  getDwtSamplePath,
+  getDdvSamplePath,
+  readCodeFile,
+  getMainCodeFile,
+  getMimeTypeForExtension,
+  getDbrServerSampleContent
+} from "./resource-index/samples.js";
+import { parseResourceUri, parseSampleUri, getSampleIdFromUri } from "./resource-index/uri.js";
+import {
+  parseMajorVersion,
+  detectMajorFromQuery,
+  formatLegacyLinksForDBR,
+  getLegacyLink,
+  ensureLatestMajor as ensureLatestMajorWithPolicy,
+  buildVersionPolicyText as buildVersionPolicyTextWithPolicy
+} from "./resource-index/version-policy.js";
+import {
+  buildIndexData as buildIndexDataFromBuilders,
+  buildResourceIndex as buildResourceIndexFromBuilders
+} from "./resource-index/builders.js";
+
+const registry = JSON.parse(readFileSync(registryPath, "utf8"));
+
+function inferDbrMobilePlatform(articlePath) {
+  const normalized = String(articlePath || "").replace(/\\/g, "/").toLowerCase();
+  const match = normalized.match(/^programming\/([^/]+)\//);
+  if (!match) return "mobile";
+  const segment = match[1];
+  if (segment === "objectivec-swift") return "ios";
+  if (segment === "android" || segment === "ios" || segment === "maui" || segment === "react-native" || segment === "flutter") {
+    return segment;
+  }
+  return "mobile";
+}
+
+function inferDbrServerPlatform(articlePath) {
+  const normalized = String(articlePath || "").replace(/\\/g, "/").toLowerCase();
+  const match = normalized.match(/^programming\/([^/]+)\//);
+  if (!match) return "server";
+  const segment = match[1];
+  if (segment === "cplusplus") return "cpp";
+  if (segment === "python" || segment === "java" || segment === "dotnet" || segment === "cpp") return segment;
+  return "server";
+}
+
+function withDbrScope(articles, edition, platformResolver) {
+  return (articles || []).map((article) => ({
+    ...article,
+    edition,
+    platform: platformResolver ? platformResolver(article.path) : "web"
+  }));
+}
+
+const dbrWebDocs = withDbrScope(
+  loadMarkdownDocs({
+    rootDir: DOC_ROOTS.dbrWeb,
+    urlBase: DOCS_CONFIG.dbrWeb.urlBase,
+    excludeDirs: DOCS_CONFIG.dbrWeb.excludeDirs,
+    excludeFiles: DOCS_CONFIG.dbrWeb.excludeFiles
+  }).articles,
+  "web",
+  () => "web"
+);
+
+const dbrMobileDocs = withDbrScope(
+  loadMarkdownDocs({
+    rootDir: DOC_ROOTS.dbrMobile,
+    urlBase: DOCS_CONFIG.dbrMobile.urlBase,
+    excludeDirs: DOCS_CONFIG.dbrMobile.excludeDirs,
+    excludeFiles: DOCS_CONFIG.dbrMobile.excludeFiles
+  }).articles,
+  "mobile",
+  inferDbrMobilePlatform
+);
+
+const dbrServerDocs = withDbrScope(
+  loadMarkdownDocs({
+    rootDir: DOC_ROOTS.dbrServer,
+    urlBase: DOCS_CONFIG.dbrServer.urlBase,
+    excludeDirs: DOCS_CONFIG.dbrServer.excludeDirs,
+    excludeFiles: DOCS_CONFIG.dbrServer.excludeFiles
+  }).articles,
+  "server",
+  inferDbrServerPlatform
+);
+
+const dwtDocs = loadMarkdownDocs({
+  rootDir: DOC_ROOTS.dwtArticles,
+  urlBase: DOCS_CONFIG.dwt.urlBase,
+  includeDirNames: DOCS_CONFIG.dwt.includeDirNames
+});
+
+const ddvDocs = loadMarkdownDocs({
+  rootDir: DOC_ROOTS.ddv,
+  urlBase: DOCS_CONFIG.ddv.urlBase,
+  excludeDirs: DOCS_CONFIG.ddv.excludeDirs,
+  excludeFiles: DOCS_CONFIG.ddv.excludeFiles
+});
+
+const dbrServerSdk = registry.sdks["dbr-server"];
+
+const LATEST_VERSIONS = {
+  dbr: {
+    mobile: registry.sdks["dbr-mobile"].version,
+    web: registry.sdks["dbr-web"].version,
+    server: dbrServerSdk.version,
+    python: dbrServerSdk.version
+  },
+  dwt: {
+    web: registry.sdks.dwt.version
+  },
+  ddv: {
+    web: registry.sdks.ddv.version
+  }
+};
+
+const LATEST_MAJOR = {
+  dbr: parseMajorVersion(registry.sdks["dbr-mobile"].version),
+  dwt: parseMajorVersion(registry.sdks.dwt.version),
+  ddv: parseMajorVersion(registry.sdks.ddv.version)
+};
+
+setWebFrameworkPlatformsGetter(getWebFrameworkPlatforms);
+
+function ensureLatestMajor(args) {
+  return ensureLatestMajorWithPolicy({ ...args, latestMajor: LATEST_MAJOR });
+}
+
+function buildVersionPolicyText() {
+  return buildVersionPolicyTextWithPolicy(LATEST_MAJOR);
+}
+
+const resourceIndex = [];
+
+function addResourceToIndex(entry) {
+  resourceIndex.push(entry);
+}
+
+function buildIndexData() {
+  return buildIndexDataFromBuilders({
+    LATEST_VERSIONS,
+    LATEST_MAJOR,
+    dbrWebDocs,
+    dbrMobileDocs,
+    dbrServerDocs,
+    dwtDocs,
+    ddvDocs,
+    discoverWebSamples,
+    getDbrWebFrameworkPlatforms,
+    getDbrMobilePlatforms,
+    getDbrServerPlatforms,
+    discoverMobileSamples,
+    discoverDbrServerSamples,
+    discoverDwtSamples,
+    discoverDdvSamples,
+    getDdvWebFrameworkPlatforms
+  });
+}
+
+function buildResourceIndex() {
+  buildResourceIndexFromBuilders({
+    addResourceToIndex,
+    buildIndexData,
+    buildVersionPolicyText,
+    LATEST_VERSIONS,
+    LATEST_MAJOR,
+    dbrWebDocs,
+    dbrMobileDocs,
+    dbrServerDocs,
+    dwtDocs,
+    ddvDocs,
+    discoverMobileSamples,
+    getDbrMobilePlatforms,
+    getMobileSamplePath,
+    getMainCodeFile,
+    readCodeFile,
+    getMimeTypeForExtension,
+    getDbrServerPlatforms,
+    discoverDbrServerSamples,
+    getDbrServerSampleContent,
+    discoverWebSamples,
+    getWebSamplePath,
+    discoverDwtSamples,
+    getDwtSamplePath,
+    discoverDdvSamples,
+    getDdvSamplePath,
+    findCodeFilesInSample
+  });
+}
+
+buildResourceIndex();
+
+const resourceIndexByUri = new Map(resourceIndex.map((entry) => [entry.uri, entry]));
+
+function editionMatches(normalizedEdition, entryEdition) {
+  if (!normalizedEdition) return true;
+  if (normalizedEdition === entryEdition) return true;
+  if (normalizedEdition === "server" && entryEdition === "python") return true;
+  if (normalizedEdition === "python" && entryEdition === "server") return true;
+  return false;
+}
+
+function platformMatches(normalizedPlatform, entry) {
+  if (!normalizedPlatform) return true;
+  if (normalizedPlatform === entry.platform) return true;
+  if (normalizedPlatform === "web") return entry.platform === "web";
+  if (isWebFrameworkPlatform(normalizedPlatform)) {
+    if (entry.platform === "web" && Array.isArray(entry.tags)) {
+      const tags = entry.tags.map((tag) => String(tag).toLowerCase());
+      const aliases = WEB_FRAMEWORK_TAG_ALIASES[normalizedPlatform] || [normalizedPlatform];
+      return aliases.some((alias) => tags.includes(alias));
+    }
+    return entry.platform === normalizedPlatform;
+  }
+  return false;
+}
+
+function getSampleEntries({ product, edition, platform }) {
+  const normalizedProduct = normalizeProduct(product);
+  const normalizedPlatform = normalizePlatform(platform);
+  const normalizedEdition = normalizeEdition(edition, normalizedPlatform, normalizedProduct);
+
+  return resourceIndex.filter((entry) => {
+    if (entry.type !== "sample") return false;
+    if (normalizedProduct && entry.product !== normalizedProduct) return false;
+    if (!editionMatches(normalizedEdition, entry.edition)) return false;
+    if (!platformMatches(normalizedPlatform, entry)) return false;
+    return true;
+  });
+}
+
+function getDisplayEdition(entryEdition) {
+  return entryEdition === "python" ? "server" : entryEdition;
+}
+
+function getDisplayPlatform(entryPlatform) {
+  return entryPlatform === "web" ? "js" : entryPlatform;
+}
+
+function formatScopeLabel(entry) {
+  const displayEdition = getDisplayEdition(entry.edition);
+  const displayPlatform = getDisplayPlatform(entry.platform);
+  return [entry.product || "general", displayEdition || "", displayPlatform || ""].filter(Boolean).join("/");
+}
+
+function getPinnedResources() {
+  return resourceIndex.filter((entry) => entry.pinned);
+}
+
+async function readResourceContent(uri) {
+  const resource = resourceIndexByUri.get(uri);
+  if (!resource) return null;
+  const content = await resource.loadContent();
+  return {
+    uri,
+    mimeType: content.mimeType || resource.mimeType || "text/plain",
+    text: content.text,
+    blob: content.blob
+  };
+}
+
+function getRagSignatureData() {
+  return {
+    resourceCount: resourceIndex.length,
+    dbrWebDocCount: dbrWebDocs.length,
+    dbrMobileDocCount: dbrMobileDocs.length,
+    dbrServerDocCount: dbrServerDocs.length,
+    dwtDocCount: dwtDocs.articles.length,
+    ddvDocCount: ddvDocs.articles.length,
+    versions: LATEST_VERSIONS,
+    dataSources: {
+      dbrWebSamplesHead: readSubmoduleHead(SAMPLE_ROOTS.dbrWeb),
+      dbrMobileSamplesHead: readSubmoduleHead(SAMPLE_ROOTS.dbrMobile),
+      dbrPythonSamplesHead: readSubmoduleHead(SAMPLE_ROOTS.dbrPython),
+      dbrDotnetSamplesHead: readSubmoduleHead(SAMPLE_ROOTS.dbrDotnet),
+      dbrJavaSamplesHead: readSubmoduleHead(SAMPLE_ROOTS.dbrJava),
+      dbrCppSamplesHead: readSubmoduleHead(SAMPLE_ROOTS.dbrCpp),
+      dbrMauiSamplesHead: readSubmoduleHead(SAMPLE_ROOTS.dbrMaui),
+      dbrReactNativeSamplesHead: readSubmoduleHead(SAMPLE_ROOTS.dbrReactNative),
+      dbrFlutterSamplesHead: readSubmoduleHead(SAMPLE_ROOTS.dbrFlutter),
+      dbrNodejsSamplesHead: readSubmoduleHead(SAMPLE_ROOTS.dbrNodejs),
+      dwtSamplesHead: readSubmoduleHead(SAMPLE_ROOTS.dwt),
+      ddvSamplesHead: readSubmoduleHead(SAMPLE_ROOTS.ddv),
+      dbrWebDocsHead: readSubmoduleHead(DOC_ROOTS.dbrWeb),
+      dbrMobileDocsHead: readSubmoduleHead(DOC_ROOTS.dbrMobile),
+      dbrServerDocsHead: readSubmoduleHead(DOC_ROOTS.dbrServer),
+      dwtDocsHead: readSubmoduleHead(DOC_ROOTS.dwt),
+      ddvDocsHead: readSubmoduleHead(DOC_ROOTS.ddv),
+      registryPath
+    }
+  };
+}
+
+export {
+  registry,
+  LATEST_VERSIONS,
+  LATEST_MAJOR,
+  resourceIndex,
+  resourceIndexByUri,
+  getRagSignatureData,
+  getCodeFileExtensions,
+  isCodeFile,
+  discoverMobileSamples,
+  discoverDbrServerSamples,
+  discoverPythonSamples,
+  discoverWebSamples,
+  getWebSamplePath,
+  discoverDwtSamples,
+  discoverDdvSamples,
+  mapDdvSampleToFramework,
+  getDbrWebFrameworkPlatforms,
+  getDdvWebFrameworkPlatforms,
+  getWebFrameworkPlatforms,
+  findCodeFilesInSample,
+  getDbrServerSamplePath,
+  getDbrMobilePlatforms,
+  getDbrServerPlatforms,
+  getMobileSamplePath,
+  getPythonSamplePath,
+  getDwtSamplePath,
+  getDdvSamplePath,
+  readCodeFile,
+  getMainCodeFile,
+  parseMajorVersion,
+  getMimeTypeForExtension,
+  addResourceToIndex,
+  formatLegacyLinksForDBR,
+  getLegacyLink,
+  detectMajorFromQuery,
+  ensureLatestMajor,
+  parseResourceUri,
+  parseSampleUri,
+  getSampleIdFromUri,
+  getSampleEntries,
+  buildVersionPolicyText,
+  buildIndexData,
+  buildResourceIndex,
+  editionMatches,
+  platformMatches,
+  getDisplayEdition,
+  getDisplayPlatform,
+  formatScopeLabel,
+  getPinnedResources,
+  readResourceContent,
+  normalizeSdkId,
+  normalizePlatform,
+  normalizeLanguage,
+  normalizeApiLevel,
+  normalizeSampleName,
+  normalizeProduct,
+  normalizeEdition,
+  isServerPlatform,
+  isWebFrameworkPlatform,
+  isWebPlatform,
+  inferProductFromQuery
+};