simple-dynamsoft-mcp 6.3.0 → 7.0.0

package/src/rag/search-utils.js

@@ -0,0 +1,166 @@
+import Fuse from "fuse.js";
+
+function createFuseSearch(resourceIndex) {
+  return new Fuse(resourceIndex, {
+    keys: ["title", "summary", "tags", "uri"],
+    threshold: 0.35,
+    ignoreLocation: true,
+    includeScore: true
+  });
+}
+
+function attachScore(entry, score, includeScore) {
+  if (!includeScore || !Number.isFinite(score)) return entry;
+  return { ...entry, score };
+}
+
+function normalizeSearchFilters({ product, edition, platform, type }, normalizers) {
+  const normalizedProduct = normalizers.normalizeProduct(product);
+  const normalizedPlatform = normalizers.normalizePlatform(platform);
+  const normalizedEdition = normalizers.normalizeEdition(edition, normalizedPlatform, normalizedProduct);
+  return {
+    product: normalizedProduct,
+    edition: normalizedEdition,
+    platform: normalizedPlatform,
+    type: type || "any"
+  };
+}
+
+function entryMatchesScope(entry, filters, matchers) {
+  if (filters.product && entry.product !== filters.product) return false;
+  if (filters.edition && !matchers.editionMatches(filters.edition, entry.edition)) return false;
+  if (filters.platform && !matchers.platformMatches(filters.platform, entry)) return false;
+  if (filters.type && filters.type !== "any" && entry.type !== filters.type) return false;
+  return true;
+}
+
+function normalizeText(text) {
+  return String(text || "").replace(/\s+/g, " ").trim();
+}
+
+function truncateText(text, maxChars) {
+  if (!maxChars || maxChars <= 0) return text;
+  if (text.length <= maxChars) return text;
+  return text.slice(0, Math.max(0, maxChars));
+}
+
+function chunkText(text, chunkSize, chunkOverlap, maxChunks) {
+  const cleaned = normalizeText(text);
+  if (!cleaned) return [];
+  if (!chunkSize || chunkSize <= 0) return [cleaned];
+  const overlap = Math.min(Math.max(0, chunkOverlap), Math.max(0, chunkSize - 1));
+  const chunks = [];
+  let start = 0;
+  while (start < cleaned.length) {
+    const end = Math.min(start + chunkSize, cleaned.length);
+    const chunk = cleaned.slice(start, end).trim();
+    if (chunk) chunks.push(chunk);
+    if (end >= cleaned.length) break;
+    start = Math.max(0, end - overlap);
+    if (maxChunks && chunks.length >= maxChunks) break;
+  }
+  return chunks;
+}
+
+function buildEntryBaseText(entry) {
+  const parts = [entry.title, entry.summary];
+  if (Array.isArray(entry.tags) && entry.tags.length > 0) {
+    parts.push(entry.tags.join(", "));
+  }
+  return normalizeText(parts.filter(Boolean).join("\n"));
+}
+
+function buildEmbeddingItems(resourceIndex, ragConfig) {
+  const items = [];
+  for (const entry of resourceIndex) {
+    const baseText = buildEntryBaseText(entry);
+    if (!baseText) continue;
+    if (entry.type === "doc" && entry.embedText) {
+      const chunks = chunkText(entry.embedText, ragConfig.chunkSize, ragConfig.chunkOverlap, ragConfig.maxChunksPerDoc);
+      if (chunks.length === 0) {
+        items.push({
+          id: entry.id,
+          uri: entry.uri,
+          text: truncateText(baseText, ragConfig.maxTextChars)
+        });
+        continue;
+      }
+      chunks.forEach((chunk, index) => {
+        const combined = [baseText, chunk].filter(Boolean).join("\n\n");
+        items.push({
+          id: `${entry.id}#${index}`,
+          uri: entry.uri,
+          text: truncateText(combined, ragConfig.maxTextChars)
+        });
+      });
+      continue;
+    }
+    items.push({
+      id: entry.id,
+      uri: entry.uri,
+      text: truncateText(baseText, ragConfig.maxTextChars)
+    });
+  }
+  return items;
+}
+
+function buildIndexSignature({ pkgVersion, signatureData, ragConfig }) {
+  return JSON.stringify({
+    packageVersion: pkgVersion,
+    resourceCount: signatureData.resourceCount,
+    dcvCoreDocCount: signatureData.dcvCoreDocCount,
+    dcvWebDocCount: signatureData.dcvWebDocCount,
+    dcvMobileDocCount: signatureData.dcvMobileDocCount,
+    dcvServerDocCount: signatureData.dcvServerDocCount,
+    dbrWebDocCount: signatureData.dbrWebDocCount,
+    dbrMobileDocCount: signatureData.dbrMobileDocCount,
+    dbrServerDocCount: signatureData.dbrServerDocCount,
+    dwtDocCount: signatureData.dwtDocCount,
+    ddvDocCount: signatureData.ddvDocCount,
+    versions: signatureData.versions,
+    dataSources: signatureData.dataSources,
+    chunkSize: ragConfig.chunkSize,
+    chunkOverlap: ragConfig.chunkOverlap,
+    maxChunksPerDoc: ragConfig.maxChunksPerDoc,
+    maxTextChars: ragConfig.maxTextChars
+  });
+}
+
+function normalizeVector(vector) {
+  let sum = 0;
+  for (const value of vector) {
+    sum += value * value;
+  }
+  const norm = Math.sqrt(sum);
+  if (!norm) return vector.map(() => 0);
+  return vector.map((value) => value / norm);
+}
+
+function dotProduct(a, b) {
+  const len = Math.min(a.length, b.length);
+  let sum = 0;
+  for (let i = 0; i < len; i++) {
+    sum += a[i] * b[i];
+  }
+  return sum;
+}
+
+function isRateLimitError(error, isRateLimitGeminiStatus) {
+  if (error?.rateLimited) return true;
+  const status = Number(error?.status);
+  return isRateLimitGeminiStatus(status);
+}
+
+export {
+  createFuseSearch,
+  attachScore,
+  normalizeSearchFilters,
+  entryMatchesScope,
+  normalizeText,
+  truncateText,
+  buildEmbeddingItems,
+  buildIndexSignature,
+  normalizeVector,
+  dotProduct,
+  isRateLimitError
+};

package/src/rag/vector-cache.js

@@ -0,0 +1,323 @@
+import { readFileSync, existsSync, writeFileSync, mkdirSync, readdirSync, copyFileSync, rmSync, statSync } from "node:fs";
+import { join, basename, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { tmpdir } from "node:os";
+import * as tar from "tar";
+
+function ensureDirectory(path) {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+  }
+}
+
+function makeCacheFileName(provider, model, cacheKey) {
+  const safeModel = String(model || "default").replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 32);
+  return `rag-${provider}-${safeModel}-${cacheKey.slice(0, 12)}.json`;
+}
+
+function makeCheckpointFileName(provider, model, cacheKey) {
+  const safeModel = String(model || "default").replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 32);
+  return `rag-${provider}-${safeModel}-${cacheKey.slice(0, 12)}.checkpoint.json`;
+}
+
+function loadVectorIndexCache(
+  cacheFile,
+  { cacheKey, signature, provider, model, requireSignature = false } = {}
+) {
+  if (!existsSync(cacheFile)) {
+    return { hit: false, reason: "missing", payload: null };
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(cacheFile, "utf8"));
+    if (!parsed || (cacheKey && parsed.cacheKey !== cacheKey)) {
+      return { hit: false, reason: "cache_key_mismatch", payload: null };
+    }
+    if (!Array.isArray(parsed.items) || !Array.isArray(parsed.vectors)) {
+      return { hit: false, reason: "invalid_payload", payload: null };
+    }
+    const meta = parsed.meta || {};
+    if (provider && meta.provider && meta.provider !== provider) {
+      return { hit: false, reason: "provider_mismatch", payload: null };
+    }
+    if (model && meta.model && meta.model !== model) {
+      return { hit: false, reason: "model_mismatch", payload: null };
+    }
+    if (signature) {
+      if (!meta.signature) {
+        if (requireSignature) {
+          return { hit: false, reason: "missing_signature", payload: null };
+        }
+      } else if (meta.signature !== signature) {
+        return { hit: false, reason: "signature_mismatch", payload: null };
+      }
+    }
+    return { hit: true, reason: "ok", payload: parsed };
+  } catch {
+    return { hit: false, reason: "parse_error", payload: null };
+  }
+}
+
+function saveVectorIndexCache(cacheDir, cacheFile, payload) {
+  ensureDirectory(cacheDir);
+  writeFileSync(cacheFile, JSON.stringify(payload));
+}
+
+function loadVectorIndexCheckpoint(checkpointFile, expectedKey, expectedItems) {
+  if (!existsSync(checkpointFile)) {
+    return { hit: false, reason: "missing", payload: null };
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(checkpointFile, "utf8"));
+    if (!parsed || parsed.cacheKey !== expectedKey) {
+      return { hit: false, reason: "cache_key_mismatch", payload: null };
+    }
+    if (!Array.isArray(parsed.items) || !Array.isArray(parsed.vectors)) {
+      return { hit: false, reason: "invalid_payload", payload: null };
+    }
+    if (parsed.items.length !== expectedItems.length) {
+      return { hit: false, reason: "items_length_mismatch", payload: null };
+    }
+    for (let i = 0; i < expectedItems.length; i += 1) {
+      if (parsed.items[i]?.id !== expectedItems[i]?.id || parsed.items[i]?.uri !== expectedItems[i]?.uri) {
+        return { hit: false, reason: "items_mismatch", payload: null };
+      }
+    }
+    if (parsed.vectors.length > expectedItems.length) {
+      return { hit: false, reason: "vectors_overflow", payload: null };
+    }
+    return { hit: true, reason: "ok", payload: parsed };
+  } catch {
+    return { hit: false, reason: "parse_error", payload: null };
+  }
+}
+
+function saveVectorIndexCheckpoint(cacheDir, checkpointFile, payload) {
+  ensureDirectory(cacheDir);
+  writeFileSync(checkpointFile, JSON.stringify(payload));
+}
+
+function clearVectorIndexCheckpoint(checkpointFile) {
+  if (existsSync(checkpointFile)) {
+    rmSync(checkpointFile, { force: true });
+  }
+}
+
+function listFilesRecursive(rootDir) {
+  const files = [];
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const entries = readdirSync(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+      } else if (entry.isFile()) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+
+function readSignaturePackageVersion(signatureRaw) {
+  if (!signatureRaw) return "";
+  try {
+    const parsed = JSON.parse(signatureRaw);
+    return String(parsed?.packageVersion || "");
+  } catch {
+    return "";
+  }
+}
+
+function listDownloadedCacheCandidatesByProvider(extractRoot, expectedCacheFileName, cacheKey, provider) {
+  const allFiles = listFilesRecursive(extractRoot).filter((path) => path.toLowerCase().endsWith(".json")).sort();
+  const expectedPath = allFiles.find((path) => basename(path) === expectedCacheFileName);
+
+  const cachePrefix = cacheKey.slice(0, 12);
+  const prefixPath = allFiles.find((path) => {
+    const name = basename(path);
+    return name.startsWith(`rag-${provider}-`) && name.endsWith(`-${cachePrefix}.json`);
+  });
+
+  const providerFiles = allFiles.filter((path) => basename(path).startsWith(`rag-${provider}-`));
+  const unique = [];
+  for (const path of [expectedPath, prefixPath, ...providerFiles]) {
+    if (!path) continue;
+    if (!unique.includes(path)) unique.push(path);
+  }
+  return unique;
+}
+
+function resolvePrebuiltIndexUrlCandidates(provider, ragConfig, legacyPrebuiltIndexUrl) {
+  const override = String(ragConfig.prebuiltIndexUrl || "").trim();
+  if (override) return [override];
+
+  const candidates = [];
+  if (provider === "local") {
+    candidates.push(String(ragConfig.prebuiltIndexUrlLocal || "").trim());
+  } else if (provider === "gemini") {
+    candidates.push(String(ragConfig.prebuiltIndexUrlGemini || "").trim());
+  }
+  candidates.push(legacyPrebuiltIndexUrl);
+
+  const deduped = [];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    if (!deduped.includes(candidate)) deduped.push(candidate);
+  }
+  return deduped;
+}
+
+async function downloadPrebuiltArchive(url, outputPath, timeoutMs) {
+  const source = String(url || "").trim();
+  if (!source) {
+    throw new Error("prebuilt URL is empty");
+  }
+
+  if (source.startsWith("file://")) {
+    copyFileSync(fileURLToPath(source), outputPath);
+    return { sourceType: "file", size: statSync(outputPath).size };
+  }
+
+  if (!/^https?:\/\//i.test(source)) {
+    copyFileSync(resolve(source), outputPath);
+    return { sourceType: "file", size: statSync(outputPath).size };
+  }
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), Math.max(1000, timeoutMs));
+  try {
+    const response = await fetch(source, { signal: controller.signal });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    writeFileSync(outputPath, Buffer.from(arrayBuffer));
+    return { sourceType: "http", size: arrayBuffer.byteLength };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function createVectorCacheHelpers({ ragConfig, pkgVersion, legacyPrebuiltIndexUrl, logRag }) {
+  const prebuiltDownloadAttempts = new Map();
+
+  async function maybeDownloadPrebuiltVectorIndex({ provider, model, cacheKey, signature, cacheFile }) {
+    if (!["local", "gemini"].includes(provider)) {
+      return { downloaded: false, reason: "provider_not_supported" };
+    }
+    if (!ragConfig.prebuiltIndexAutoDownload) {
+      return { downloaded: false, reason: "auto_download_disabled" };
+    }
+
+    const sourceUrls = resolvePrebuiltIndexUrlCandidates(provider, ragConfig, legacyPrebuiltIndexUrl);
+    if (sourceUrls.length === 0) {
+      return { downloaded: false, reason: "url_not_set" };
+    }
+
+    const attemptKey = `${provider}:${cacheKey}:${sourceUrls.join("|")}`;
+    if (prebuiltDownloadAttempts.has(attemptKey)) {
+      return prebuiltDownloadAttempts.get(attemptKey);
+    }
+
+    const expectedCacheFileName = makeCacheFileName(provider, model, cacheKey);
+    const attempt = (async () => {
+      let lastReason = "not_attempted";
+      for (const sourceUrl of sourceUrls) {
+        const tempRoot = join(
+          tmpdir(),
+          `simple-dynamsoft-mcp-rag-prebuilt-${Date.now()}-${Math.random().toString(16).slice(2)}`
+        );
+        const archivePath = join(tempRoot, "prebuilt-rag-index.tar.gz");
+        const extractRoot = join(tempRoot, "extract");
+
+        ensureDirectory(extractRoot);
+        try {
+          logRag(
+            `prebuilt index download start provider=${provider} url=${sourceUrl} timeout_ms=${ragConfig.prebuiltIndexTimeoutMs}`
+          );
+          const downloaded = await downloadPrebuiltArchive(sourceUrl, archivePath, ragConfig.prebuiltIndexTimeoutMs);
+          logRag(
+            `prebuilt index downloaded provider=${provider} source=${downloaded.sourceType} size=${downloaded.size}B url=${sourceUrl}`
+          );
+
+          await tar.x({
+            file: archivePath,
+            cwd: extractRoot,
+            strict: true
+          });
+
+          const candidateFiles = listDownloadedCacheCandidatesByProvider(
+            extractRoot,
+            expectedCacheFileName,
+            cacheKey,
+            provider
+          );
+          if (candidateFiles.length === 0) {
+            throw new Error(`cache_file_not_found expected=${expectedCacheFileName}`);
+          }
+
+          for (const sourceCacheFile of candidateFiles) {
+            const candidateCache = loadVectorIndexCache(sourceCacheFile, {
+              provider,
+              model
+            });
+            if (!candidateCache.hit) {
+              continue;
+            }
+
+            const cachePackageVersion = readSignaturePackageVersion(candidateCache.payload?.meta?.signature);
+            if (!cachePackageVersion || cachePackageVersion !== pkgVersion) {
+              continue;
+            }
+
+            const migratedPayload = {
+              ...candidateCache.payload,
+              cacheKey,
+              meta: {
+                ...(candidateCache.payload.meta || {}),
+                provider,
+                model,
+                signature
+              }
+            };
+            saveVectorIndexCache(ragConfig.cacheDir, cacheFile, migratedPayload);
+            logRag(
+              `prebuilt index installed provider=${provider} cache_file=${cacheFile} source=${basename(sourceCacheFile)} mode=version_only_compat version=${cachePackageVersion}`
+            );
+            return { downloaded: true, reason: "installed_version_only_compat" };
+          }
+
+          throw new Error(
+            `no_compatible_cache expected=${expectedCacheFileName} found=${candidateFiles.map((path) => basename(path)).join(",")}`
+          );
+        } catch (error) {
+          lastReason = `${sourceUrl} => ${error.message}`;
+          logRag(`prebuilt index unavailable provider=${provider} url=${sourceUrl} reason=${error.message}`);
+        } finally {
+          rmSync(tempRoot, { recursive: true, force: true });
+        }
+      }
+      return { downloaded: false, reason: lastReason };
+    })();
+
+    prebuiltDownloadAttempts.set(attemptKey, attempt);
+    return attempt;
+  }
+
+  return {
+    makeCacheFileName,
+    makeCheckpointFileName,
+    loadVectorIndexCache,
+    saveVectorIndexCache: (cacheFile, payload) => saveVectorIndexCache(ragConfig.cacheDir, cacheFile, payload),
+    loadVectorIndexCheckpoint,
+    saveVectorIndexCheckpoint: (checkpointFile, payload) => saveVectorIndexCheckpoint(ragConfig.cacheDir, checkpointFile, payload),
+    clearVectorIndexCheckpoint,
+    maybeDownloadPrebuiltVectorIndex
+  };
+}
+
+export {
+  createVectorCacheHelpers
+};

package/src/server/create-server.js

@@ -0,0 +1,168 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ensureDataScopesHydrated } from "../data/bootstrap.js";
+import { createScopeHydrator } from "./helpers/server-helpers.js";
+import { registerResourceHandlers } from "./resources/register-resources.js";
+import { registerIndexTools } from "./tools/register-index-tools.js";
+import { registerSampleTools } from "./tools/register-sample-tools.js";
+import { registerVersionTools } from "./tools/register-version-tools.js";
+import { registerQuickstartTools } from "./tools/register-quickstart-tools.js";
+import { registerProjectTools } from "./tools/register-project-tools.js";
+
+export function createMcpServerInstance({ pkgVersion, resourceIndexApi, ragApi }) {
+  const {
+    registry,
+    LATEST_VERSIONS,
+    LATEST_MAJOR,
+    discoverDwtSamples,
+    discoverDcvMobileSamples,
+    discoverDcvWebSamples,
+    findCodeFilesInSample,
+    getMobileSamplePath,
+    getDbrServerSamplePath,
+    getDcvMobileSamplePath,
+    getDcvServerSamplePath,
+    getDcvWebSamplePath,
+    getDwtSamplePath,
+    getDdvSamplePath,
+    readCodeFile,
+    getMainCodeFile,
+    ensureLatestMajor,
+    parseResourceUri,
+    parseSampleUri,
+    getSampleIdFromUri,
+    getSampleEntries,
+    buildIndexData,
+    getDisplayEdition,
+    getDisplayPlatform,
+    formatScopeLabel,
+    getPinnedResources,
+    readResourceContent,
+    refreshResourceIndex,
+    normalizePlatform,
+    normalizeApiLevel,
+    normalizeSampleName,
+    normalizeProduct,
+    normalizeEdition,
+    resourceIndex,
+    getWebSamplePath
+  } = resourceIndexApi;
+
+  const {
+    searchResources,
+    getSampleSuggestions,
+    refreshRagIndexes
+  } = ragApi;
+
+  const ensureScopeHydrated = createScopeHydrator({
+    ensureDataScopesHydrated,
+    refreshResourceIndex,
+    refreshRagIndexes
+  });
+
+const server = new McpServer({
+  name: "simple-dynamsoft-mcp",
+  version: pkgVersion,
+  description: "MCP server for latest major versions of Dynamsoft SDKs: Capture Vision, Barcode Reader, Dynamic Web TWAIN, and Document Viewer. Includes guidance for choosing DBR vs DCV by scenario."
+});
+
+registerIndexTools({
+  server,
+  ensureScopeHydrated,
+  ensureLatestMajor,
+  normalizeProduct,
+  normalizePlatform,
+  normalizeEdition,
+  buildIndexData,
+  getSampleIdFromUri,
+  formatScopeLabel,
+  searchResources
+});
+
+registerSampleTools({
+  server,
+  ensureScopeHydrated,
+  ensureLatestMajor,
+  normalizeProduct,
+  normalizePlatform,
+  normalizeEdition,
+  normalizeSampleName,
+  parseSampleUri,
+  resourceIndex,
+  getSampleEntries,
+  getSampleIdFromUri,
+  getDisplayEdition,
+  getDisplayPlatform,
+  formatScopeLabel,
+  searchResources,
+  getSampleSuggestions
+});
+
+registerVersionTools({
+  server,
+  ensureLatestMajor,
+  normalizeProduct,
+  normalizePlatform,
+  normalizeEdition,
+  LATEST_MAJOR,
+  LATEST_VERSIONS
+});
+
+registerQuickstartTools({
+  server,
+  registry,
+  ensureScopeHydrated,
+  ensureLatestMajor,
+  normalizeProduct,
+  normalizePlatform,
+  normalizeEdition,
+  normalizeApiLevel,
+  discoverDcvMobileSamples,
+  discoverDcvWebSamples,
+  findCodeFilesInSample,
+  getMobileSamplePath,
+  getDbrServerSamplePath,
+  getDcvMobileSamplePath,
+  getDcvServerSamplePath,
+  getDcvWebSamplePath,
+  getDwtSamplePath,
+  getDdvSamplePath,
+  readCodeFile,
+  getMainCodeFile,
+  getWebSamplePath
+});
+
+registerProjectTools({
+  server,
+  ensureScopeHydrated,
+  ensureLatestMajor,
+  normalizeProduct,
+  normalizePlatform,
+  normalizeEdition,
+  normalizeApiLevel,
+  normalizeSampleName,
+  parseResourceUri,
+  parseSampleUri,
+  formatScopeLabel,
+  getSampleIdFromUri,
+  discoverDwtSamples,
+  getMobileSamplePath,
+  getWebSamplePath,
+  getDbrServerSamplePath,
+  getDcvMobileSamplePath,
+  getDcvServerSamplePath,
+  getDcvWebSamplePath,
+  getDwtSamplePath,
+  getDdvSamplePath,
+  getSampleSuggestions
+});
+
+registerResourceHandlers({
+  server,
+  getPinnedResources,
+  parseResourceUri,
+  ensureLatestMajor,
+  readResourceContent
+});
+
+return server;
+}

package/src/server/helpers/server-helpers.js

@@ -0,0 +1,33 @@
+function formatScoreLabel(entry) {
+  if (!Number.isFinite(entry?.score)) return "";
+  return ` | score: ${entry.score.toFixed(3)}`;
+}
+
+function formatScoreNote(entry) {
+  if (!Number.isFinite(entry?.score)) return "";
+  return ` score=${entry.score.toFixed(3)}`;
+}
+
+function createScopeHydrator({ ensureDataScopesHydrated, refreshResourceIndex, refreshRagIndexes }) {
+  if (typeof ensureDataScopesHydrated !== "function") {
+    throw new TypeError("ensureDataScopesHydrated must be a function");
+  }
+
+  return async function ensureScopeHydrated(scope) {
+    const result = await ensureDataScopesHydrated([scope]);
+    if (!Array.isArray(result?.hydrated) || result.hydrated.length === 0) return;
+
+    if (typeof refreshResourceIndex === "function") {
+      refreshResourceIndex();
+    }
+    if (typeof refreshRagIndexes === "function") {
+      refreshRagIndexes();
+    }
+  };
+}
+
+export {
+  formatScoreLabel,
+  formatScoreNote,
+  createScopeHydrator
+};

package/src/{resource-index → server/resource-index}/paths.js

@@ -2,10 +2,10 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { DOC_DIRS, SAMPLE_DIRS } from "./config.js";
-import { getResolvedDataRoot } from "../data-root.js";
+import { getResolvedDataRoot } from "../../data/root.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const projectRoot = join(__dirname, "..", "..");
+const projectRoot = join(__dirname, "..", "..", "..");
 
 const dataRoot = getResolvedDataRoot();
 const metadataRoot = join(dataRoot, "metadata");