@ncukondo/search-hub 0.12.2 → 0.13.0

package/dist/query/validator.js.map

@@ -1 +1 @@
-{"version":3,"file":"validator.js","sources":["../../src/query/validator.ts"],"sourcesContent":["/**\n * Query Schema Validation using Zod\n *\n * Validates query YAML structure against the query DSL schema.\n * See spec/models/query-dsl.md for the full specification.\n */\n\nimport { z } from 'zod';\nimport type { QueryAST } from './types.js';\n\n/**\n * Schema for field types.\n */\nexport const fieldTypeSchema = z.enum([\n  'title',\n  'abstract',\n  'title_abstract',\n  'author',\n  'keyword',\n  'all',\n]);\n\n/**\n * Schema for term block containing search terms.\n */\nexport const termBlockSchema = z.object({\n  keywords: z.array(z.string()).min(1),\n  mesh: z.array(z.string()).optional(),\n  emtree: z.array(z.string()).optional(),\n  eric: z.array(z.string()).optional(),\n  exclude: z.array(z.string()).optional(),\n});\n\n/**\n * Schema for operator.\n */\nexport const operatorSchema = z.enum(['AND', 'OR']);\n\n/**\n * Schema for query block.\n */\nexport const queryBlockSchema = z.object({\n  field: fieldTypeSchema,\n  terms: termBlockSchema,\n  operator: operatorSchema,\n});\n\n/**\n * Schema for publication type filter.\n */\nexport const publicationTypeFilterSchema = z.object({\n  include: z.array(z.string()).optional(),\n  exclude: z.array(z.string()).optional(),\n});\n\n/**\n * Schema for filters (YAML input format with snake_case).\n * Transforms to camelCase for internal use.\n */\nexport const filtersSchema = z\n  .object({\n    year_from: z.number().int().optional(),\n    year_to: z.number().int().optional(),\n    language: z.array(z.string()).optional(),\n    publication_types: publicationTypeFilterSchema.optional(),\n  })\n  .optional()\n  .default({})\n  .transform((data) => ({\n    yearFrom: data.year_from,\n    yearTo: data.year_to,\n    languages: data.language,\n    publicationTypes: data.publication_types,\n  }));\n\n/**\n * Schema for override block (YAML input format).\n */\nexport const overrideBlockSchema = z\n  .object({\n    filters: z\n      .object({\n        year_from: z.number().int().optional(),\n        year_to: z.number().int().optional(),\n        language: z.array(z.string()).optional(),\n        publication_types: publicationTypeFilterSchema.optional(),\n      })\n      .optional(),\n    categories: z.array(z.string()).optional(),\n    source_types: z.array(z.string()).optional(),\n  })\n  .transform((data) => ({\n    filters: data.filters\n      ? {\n          yearFrom: data.filters.year_from,\n          yearTo: data.filters.year_to,\n          languages: data.filters.language,\n          publicationTypes: data.filters.publication_types,\n        }\n      : undefined,\n    categories: data.categories,\n    sourceTypes: data.source_types,\n  }));\n\n/**\n * Provider names schema.\n */\nexport const providerNameSchema = z.enum([\n  'pubmed',\n  'scopus',\n  'eric',\n  'arxiv',\n  'wos',\n  'embase',\n]);\n\n/**\n * Schema for overrides object (partial record of provider -> override).\n */\nconst overridesSchema = z\n  .object({\n    pubmed: overrideBlockSchema.optional(),\n    scopus: overrideBlockSchema.optional(),\n    eric: overrideBlockSchema.optional(),\n    arxiv: overrideBlockSchema.optional(),\n    wos: overrideBlockSchema.optional(),\n    embase: overrideBlockSchema.optional(),\n  })\n  .optional()\n  .default({});\n\n/**\n * Schema for the complete query file (YAML input format).\n * Transforms to QueryAST for internal use.\n */\nexport const queryFileSchema = z\n  .object({\n    name: z.string().min(1),\n    description: z.string().optional(),\n    query: z.array(queryBlockSchema).min(1),\n    filters: filtersSchema,\n    overrides: overridesSchema,\n  })\n  .transform((data) => ({\n    name: data.name,\n    description: data.description,\n    blocks: data.query,\n    filters: data.filters,\n    overrides: data.overrides,\n  }));\n\n/**\n * Validate a parsed YAML object against the query schema.\n * Returns a validated QueryAST.\n */\nexport function validateQueryFile(data: unknown): QueryAST {\n  return queryFileSchema.parse(data);\n}\n\n/**\n * Validation error with path information.\n */\nexport class ValidationError extends Error {\n  constructor(\n    public readonly path: string,\n    message: string\n  ) {\n    super(message);\n    this.name = 'ValidationError';\n  }\n}\n\n/**\n * Format Zod validation errors into an array of ValidationError objects.\n *\n * @param data - The data to validate\n * @returns Array of ValidationError objects (empty if valid)\n */\nexport function formatValidationErrors(data: unknown): ValidationError[] {\n  const result = queryFileSchema.safeParse(data);\n\n  if (result.success) {\n    return [];\n  }\n\n  return result.error.issues.map((issue) => {\n    const path = issue.path.join('.');\n    return new ValidationError(path, issue.message);\n  });\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"validator.js","sources":["../../src/query/validator.ts"],"sourcesContent":["/**\n * Query Schema Validation using Zod\n *\n * Validates query YAML structure against the query DSL schema.\n * See spec/models/query-dsl.md for the full specification.\n */\n\nimport { z } from 'zod';\nimport type { QueryAST } from './types.js';\n\n/**\n * Schema for field types.\n */\nexport const fieldTypeSchema = z.enum([\n  'title',\n  'abstract',\n  'title_abstract',\n  'author',\n  'keyword',\n  'all',\n]);\n\n/**\n * Schema for term block containing search terms.\n */\nexport const termBlockSchema = z.object({\n  keywords: z.array(z.string()).min(1).optional(),\n  mesh: z.array(z.string()).optional(),\n  emtree: z.array(z.string()).optional(),\n  eric: z.array(z.string()).optional(),\n  exclude: z.array(z.string()).optional(),\n}).refine(\n  (data) => data.keywords?.length || data.mesh?.length || data.emtree?.length || data.eric?.length,\n  { message: 'At least one of keywords, mesh, emtree, or eric is required' }\n);\n\n/**\n * Schema for operator.\n */\nexport const operatorSchema = z.enum(['AND', 'OR']);\n\n/**\n * Schema for query block.\n */\nexport const queryBlockSchema = z.object({\n  field: fieldTypeSchema,\n  terms: termBlockSchema,\n  operator: operatorSchema,\n});\n\n/**\n * Schema for publication type filter.\n */\nexport const publicationTypeFilterSchema = z.object({\n  include: z.array(z.string()).optional(),\n  exclude: z.array(z.string()).optional(),\n});\n\n/**\n * Schema for filters (YAML input format with snake_case).\n * Transforms to camelCase for internal use.\n */\nexport const filtersSchema = z\n  .object({\n    year_from: z.number().int().optional(),\n    year_to: z.number().int().optional(),\n    language: z.array(z.string()).optional(),\n    publication_types: publicationTypeFilterSchema.optional(),\n  })\n  .optional()\n  .default({})\n  .transform((data) => ({\n    yearFrom: data.year_from,\n    yearTo: data.year_to,\n    languages: data.language,\n    publicationTypes: data.publication_types,\n  }));\n\n/**\n * Schema for override block (YAML input format).\n */\nexport const overrideBlockSchema = z\n  .object({\n    filters: z\n      .object({\n        year_from: z.number().int().optional(),\n        year_to: z.number().int().optional(),\n        language: z.array(z.string()).optional(),\n        publication_types: publicationTypeFilterSchema.optional(),\n      })\n      .optional(),\n    categories: z.array(z.string()).optional(),\n    source_types: z.array(z.string()).optional(),\n  })\n  .transform((data) => ({\n    filters: data.filters\n      ? {\n          yearFrom: data.filters.year_from,\n          yearTo: data.filters.year_to,\n          languages: data.filters.language,\n          publicationTypes: data.filters.publication_types,\n        }\n      : undefined,\n    categories: data.categories,\n    sourceTypes: data.source_types,\n  }));\n\n/**\n * Provider names schema.\n */\nexport const providerNameSchema = z.enum([\n  'pubmed',\n  'scopus',\n  'eric',\n  'arxiv',\n  'wos',\n  'embase',\n]);\n\n/**\n * Schema for overrides object (partial record of provider -> override).\n */\nconst overridesSchema = z\n  .object({\n    pubmed: overrideBlockSchema.optional(),\n    scopus: overrideBlockSchema.optional(),\n    eric: overrideBlockSchema.optional(),\n    arxiv: overrideBlockSchema.optional(),\n    wos: overrideBlockSchema.optional(),\n    embase: overrideBlockSchema.optional(),\n  })\n  .optional()\n  .default({});\n\n/**\n * Schema for the complete query file (YAML input format).\n * Transforms to QueryAST for internal use.\n */\nexport const queryFileSchema = z\n  .object({\n    name: z.string().min(1),\n    description: z.string().optional(),\n    query: z.array(queryBlockSchema).min(1),\n    filters: filtersSchema,\n    overrides: overridesSchema,\n  })\n  .transform((data) => ({\n    name: data.name,\n    description: data.description,\n    blocks: data.query,\n    filters: data.filters,\n    overrides: data.overrides,\n  }));\n\n/**\n * Validate a parsed YAML object against the query schema.\n * Returns a validated QueryAST.\n */\nexport function validateQueryFile(data: unknown): QueryAST {\n  return queryFileSchema.parse(data);\n}\n\n/**\n * Validation error with path information.\n */\nexport class ValidationError extends Error {\n  constructor(\n    public readonly path: string,\n    message: string\n  ) {\n    super(message);\n    this.name = 'ValidationError';\n  }\n}\n\n/**\n * Format Zod validation errors into an array of ValidationError objects.\n *\n * @param data - The data to validate\n * @returns Array of ValidationError objects (empty if valid)\n */\nexport function formatValidationErrors(data: unknown): ValidationError[] {\n  const result = queryFileSchema.safeParse(data);\n\n  if (result.success) {\n    return [];\n  }\n\n  return result.error.issues.map((issue) => {\n    const path = issue.path.join('.');\n    return new ValidationError(path, issue.message);\n  });\n}\n"],"names":[],"mappings":"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"}

package/dist/query/vocab-cache.d.ts

@@ -0,0 +1,15 @@
+import { MeSHLookupResult } from './mesh-lookup.js';
+export declare class VocabCache {
+    private store;
+    private readonly cachePath;
+    private readonly ttlMs;
+    constructor(options?: {
+        cachePath?: string;
+        ttlMs?: number;
+    });
+    load(): Promise<void>;
+    save(): Promise<void>;
+    get(vocabulary: string, term: string): MeSHLookupResult | undefined;
+    set(vocabulary: string, term: string, result: MeSHLookupResult): void;
+}
+//# sourceMappingURL=vocab-cache.d.ts.map

package/dist/query/vocab-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vocab-cache.d.ts","sourceRoot":"","sources":["../../src/query/vocab-cache.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAWzD,qBAAa,UAAU;IACrB,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;gBAEnB,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;IAOtD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAcrB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3B,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAanE,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,GAAG,IAAI;CAItE"}

package/dist/query/vocab-cache.js

@@ -0,0 +1,44 @@
+import { readFile, mkdir, writeFile } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { getConfigDir } from "../config/paths.js";
+const DEFAULT_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+class VocabCache {
+  store = {};
+  cachePath;
+  ttlMs;
+  constructor(options) {
+    this.cachePath = options?.cachePath ?? join(getConfigDir(), "cache", "vocab-lookup.json");
+    this.ttlMs = options?.ttlMs ?? DEFAULT_TTL_MS;
+  }
+  async load() {
+    try {
+      const raw = await readFile(this.cachePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      this.store = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
+    } catch {
+      this.store = {};
+    }
+  }
+  async save() {
+    await mkdir(dirname(this.cachePath), { recursive: true });
+    await writeFile(this.cachePath, JSON.stringify(this.store), "utf-8");
+  }
+  get(vocabulary, term) {
+    const key = `${vocabulary}:${term}`;
+    const entry = this.store[key];
+    if (!entry) return void 0;
+    if (Date.now() - entry.cachedAt > this.ttlMs) {
+      delete this.store[key];
+      return void 0;
+    }
+    return entry.result;
+  }
+  set(vocabulary, term, result) {
+    const key = `${vocabulary}:${term}`;
+    this.store[key] = { result, cachedAt: Date.now() };
+  }
+}
+export {
+  VocabCache
+};
+//# sourceMappingURL=vocab-cache.js.map

package/dist/query/vocab-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vocab-cache.js","sources":["../../src/query/vocab-cache.ts"],"sourcesContent":["/**\n * File-based cache for vocabulary lookup results.\n *\n * Stores MeSH (and future vocabulary) lookup results on disk to avoid\n * redundant API calls. TTL defaults to 30 days.\n */\nimport { readFile, writeFile, mkdir } from 'node:fs/promises';\nimport { dirname, join } from 'node:path';\nimport { getConfigDir } from '../config/paths.js';\nimport type { MeSHLookupResult } from './mesh-lookup.js';\n\nconst DEFAULT_TTL_MS = 30 * 24 * 60 * 60 * 1000; // 30 days\n\ninterface VocabCacheEntry {\n  result: MeSHLookupResult;\n  cachedAt: number; // Unix ms\n}\n\ntype VocabCacheStore = Record<string, VocabCacheEntry>;\n\nexport class VocabCache {\n  private store: VocabCacheStore = {};\n  private readonly cachePath: string;\n  private readonly ttlMs: number;\n\n  constructor(options?: { cachePath?: string; ttlMs?: number }) {\n    this.cachePath =\n      options?.cachePath ??\n      join(getConfigDir(), 'cache', 'vocab-lookup.json');\n    this.ttlMs = options?.ttlMs ?? DEFAULT_TTL_MS;\n  }\n\n  async load(): Promise<void> {\n    try {\n      const raw = await readFile(this.cachePath, 'utf-8');\n      const parsed: unknown = JSON.parse(raw);\n      this.store =\n        typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)\n          ? (parsed as VocabCacheStore)\n          : {};\n    } catch {\n      // File missing or corrupted JSON — start with empty cache\n      this.store = {};\n    }\n  }\n\n  async save(): Promise<void> {\n    await mkdir(dirname(this.cachePath), { recursive: true });\n    await writeFile(this.cachePath, JSON.stringify(this.store), 'utf-8');\n  }\n\n  get(vocabulary: string, term: string): MeSHLookupResult | undefined {\n    const key = `${vocabulary}:${term}`;\n    const entry = this.store[key];\n    if (!entry) return undefined;\n\n    if (Date.now() - entry.cachedAt > this.ttlMs) {\n      delete this.store[key];\n      return undefined;\n    }\n\n    return entry.result;\n  }\n\n  set(vocabulary: string, term: string, result: MeSHLookupResult): void {\n    const key = `${vocabulary}:${term}`;\n    this.store[key] = { result, cachedAt: Date.now() };\n  }\n}\n"],"names":[],"mappings":";;;AAWA,MAAM,iBAAiB,KAAK,KAAK,KAAK,KAAK;AASpC,MAAM,WAAW;AAAA,EACd,QAAyB,CAAA;AAAA,EAChB;AAAA,EACA;AAAA,EAEjB,YAAY,SAAkD;AAC5D,SAAK,YACH,SAAS,aACT,KAAK,aAAA,GAAgB,SAAS,mBAAmB;AACnD,SAAK,QAAQ,SAAS,SAAS;AAAA,EACjC;AAAA,EAEA,MAAM,OAAsB;AAC1B,QAAI;AACF,YAAM,MAAM,MAAM,SAAS,KAAK,WAAW,OAAO;AAClD,YAAM,SAAkB,KAAK,MAAM,GAAG;AACtC,WAAK,QACH,OAAO,WAAW,YAAY,WAAW,QAAQ,CAAC,MAAM,QAAQ,MAAM,IACjE,SACD,CAAA;AAAA,IACR,QAAQ;AAEN,WAAK,QAAQ,CAAA;AAAA,IACf;AAAA,EACF;AAAA,EAEA,MAAM,OAAsB;AAC1B,UAAM,MAAM,QAAQ,KAAK,SAAS,GAAG,EAAE,WAAW,MAAM;AACxD,UAAM,UAAU,KAAK,WAAW,KAAK,UAAU,KAAK,KAAK,GAAG,OAAO;AAAA,EACrE;AAAA,EAEA,IAAI,YAAoB,MAA4C;AAClE,UAAM,MAAM,GAAG,UAAU,IAAI,IAAI;AACjC,UAAM,QAAQ,KAAK,MAAM,GAAG;AAC5B,QAAI,CAAC,MAAO,QAAO;AAEnB,QAAI,KAAK,IAAA,IAAQ,MAAM,WAAW,KAAK,OAAO;AAC5C,aAAO,KAAK,MAAM,GAAG;AACrB,aAAO;AAAA,IACT;AAEA,WAAO,MAAM;AAAA,EACf;AAAA,EAEA,IAAI,YAAoB,MAAc,QAAgC;AACpE,UAAM,MAAM,GAAG,UAAU,IAAI,IAAI;AACjC,SAAK,MAAM,GAAG,IAAI,EAAE,QAAQ,UAAU,KAAK,MAAI;AAAA,EACjD;AACF;"}

package/dist/query/vocab-validator.d.ts

@@ -0,0 +1,71 @@
+import { QueryAST } from './types.js';
+import { MeSHLookupClient } from './mesh-lookup.js';
+import { Provider } from '../providers/base/types.js';
+import { VocabCache } from './vocab-cache.js';
+/** Supported controlled vocabulary types. */
+export type VocabType = 'mesh' | 'eric' | 'emtree';
+/**
+ * A controlled vocabulary term extracted from a QueryAST.
+ */
+export interface VocabTerm {
+    term: string;
+    vocabulary: VocabType;
+}
+/**
+ * Result of validating a single controlled vocabulary term.
+ */
+export interface VocabTermResult {
+    term: string;
+    vocabulary: VocabType;
+    found: boolean;
+    suggestions?: string[];
+}
+/**
+ * A controlled vocabulary term that failed due to an API error.
+ */
+export interface VocabTermError {
+    term: string;
+    vocabulary: VocabType;
+    error: string;
+}
+/**
+ * Result of validating all controlled vocabulary terms in a query.
+ */
+export interface VocabValidationResult {
+    valid: VocabTermResult[];
+    invalid: VocabTermResult[];
+    errors: VocabTermError[];
+}
+/**
+ * Extract all controlled vocabulary terms from a QueryAST.
+ * Terms are deduplicated across blocks.
+ */
+export declare function extractControlledVocabTerms(ast: QueryAST): VocabTerm[];
+/**
+ * A count-based vocabulary validator.
+ * Validates terms by executing a count-only search — hit count 0 means invalid.
+ */
+export interface CountVocabValidator {
+    vocabulary: VocabType;
+    countTerm: (term: string) => Promise<number>;
+}
+/**
+ * Validate all controlled vocabulary terms in a QueryAST.
+ *
+ * MeSH terms are validated via the MeSH lookup API (exact match + suggestions).
+ * ERIC/Emtree terms are validated via count-only search when countValidators are provided.
+ * Terms whose vocabulary has no validator are skipped silently.
+ *
+ * Different vocabulary groups are validated in parallel; within each group,
+ * concurrency is limited to 3 requests at a time.
+ */
+export declare function validateControlledVocab(ast: QueryAST, meshClient: MeSHLookupClient, options?: {
+    countValidators?: CountVocabValidator[];
+}): Promise<VocabValidationResult>;
+export declare function createEricCountValidator(provider: Provider, options?: {
+    cache?: VocabCache;
+}): CountVocabValidator;
+export declare function createEmtreeCountValidator(provider: Provider, options?: {
+    cache?: VocabCache;
+}): CountVocabValidator;
+//# sourceMappingURL=vocab-validator.d.ts.map

package/dist/query/vocab-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vocab-validator.d.ts","sourceRoot":"","sources":["../../src/query/vocab-validator.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,gBAAgB,EAAoB,MAAM,kBAAkB,CAAC;AAC3E,OAAO,KAAK,EAAE,QAAQ,EAAiC,MAAM,4BAA4B,CAAC;AAC1F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,6CAA6C;AAC7C,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,SAAS,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,SAAS,CAAC;IACtB,KAAK,EAAE,OAAO,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,SAAS,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,eAAe,EAAE,CAAC;IACzB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,QAAQ,GAAG,SAAS,EAAE,CA0BtE;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,SAAS,CAAC;IACtB,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CAC9C;AAsBD;;;;;;;;;GASG;AACH,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,QAAQ,EACb,UAAU,EAAE,gBAAgB,EAC5B,OAAO,CAAC,EAAE;IAAE,eAAe,CAAC,EAAE,mBAAmB,EAAE,CAAA;CAAE,GACpD,OAAO,CAAC,qBAAqB,CAAC,CA2FhC;AAgDD,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,UAAU,CAAA;CAAE,GAC/B,mBAAmB,CAErB;AAED,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,UAAU,CAAA;CAAE,GAC/B,mBAAmB,CAErB"}

package/dist/query/vocab-validator.js

@@ -0,0 +1,153 @@
+function extractControlledVocabTerms(ast) {
+  const seen = /* @__PURE__ */ new Set();
+  const terms = [];
+  const vocabFields = [
+    { key: "mesh", vocab: "mesh" },
+    { key: "eric", vocab: "eric" },
+    { key: "emtree", vocab: "emtree" }
+  ];
+  for (const block of ast.blocks) {
+    for (const { key, vocab } of vocabFields) {
+      const fieldTerms = block.terms[key];
+      if (fieldTerms) {
+        for (const term of fieldTerms) {
+          const dedupeKey = `${vocab}:${term}`;
+          if (!seen.has(dedupeKey)) {
+            seen.add(dedupeKey);
+            terms.push({ term, vocabulary: vocab });
+          }
+        }
+      }
+    }
+  }
+  return terms;
+}
+async function mapWithConcurrency(items, concurrency, fn) {
+  const results = [];
+  let index = 0;
+  async function worker() {
+    while (index < items.length) {
+      const i = index++;
+      const item = items[i];
+      if (item !== void 0) results[i] = await fn(item);
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, items.length) }, () => worker())
+  );
+  return results;
+}
+async function validateControlledVocab(ast, meshClient, options) {
+  const terms = extractControlledVocabTerms(ast);
+  const countValidatorMap = /* @__PURE__ */ new Map();
+  for (const cv of options?.countValidators ?? []) {
+    countValidatorMap.set(cv.vocabulary, cv);
+  }
+  const meshTerms = terms.filter((t) => t.vocabulary === "mesh");
+  const countGroups = /* @__PURE__ */ new Map();
+  for (const t of terms) {
+    if (t.vocabulary === "mesh") continue;
+    const validator = countValidatorMap.get(t.vocabulary);
+    if (!validator) continue;
+    const group = countGroups.get(t.vocabulary) ?? [];
+    group.push(t);
+    countGroups.set(t.vocabulary, group);
+  }
+  const CONCURRENCY = 3;
+  const meshTask = mapWithConcurrency(meshTerms, CONCURRENCY, async (vocabTerm) => {
+    let result;
+    try {
+      result = await meshClient.lookupTerm(vocabTerm.term);
+    } catch (err) {
+      return {
+        kind: "error",
+        error: {
+          term: vocabTerm.term,
+          vocabulary: vocabTerm.vocabulary,
+          error: err instanceof Error ? err.message : String(err)
+        }
+      };
+    }
+    const termResult = {
+      term: vocabTerm.term,
+      vocabulary: vocabTerm.vocabulary,
+      found: result.found,
+      ...result.suggestions ? { suggestions: result.suggestions } : {}
+    };
+    return { kind: result.found ? "valid" : "invalid", result: termResult };
+  });
+  const countTasks = [...countGroups.entries()].map(([vocabType, groupTerms]) => {
+    const validator = countValidatorMap.get(vocabType);
+    if (!validator) return Promise.resolve([]);
+    return mapWithConcurrency(groupTerms, CONCURRENCY, async (vocabTerm) => {
+      let count;
+      try {
+        count = await validator.countTerm(vocabTerm.term);
+      } catch (err) {
+        return {
+          kind: "error",
+          error: {
+            term: vocabTerm.term,
+            vocabulary: vocabTerm.vocabulary,
+            error: err instanceof Error ? err.message : String(err)
+          }
+        };
+      }
+      const termResult = {
+        term: vocabTerm.term,
+        vocabulary: vocabTerm.vocabulary,
+        found: count > 0
+      };
+      return { kind: count > 0 ? "valid" : "invalid", result: termResult };
+    });
+  });
+  const allOutcomes = (await Promise.all([meshTask, ...countTasks])).flat();
+  const valid = [];
+  const invalid = [];
+  const errors = [];
+  for (const outcome of allOutcomes) {
+    if (outcome.kind === "valid") valid.push(outcome.result);
+    else if (outcome.kind === "invalid") invalid.push(outcome.result);
+    else errors.push(outcome.error);
+  }
+  return { valid, invalid, errors };
+}
+function buildEricCountQuery(term) {
+  return `subject:"${term.replace(/"/g, "")}"`;
+}
+function buildEmtreeCountQuery(term) {
+  return `INDEXTERMS("${term.replace(/"/g, "")}")`;
+}
+function createCountValidator(vocabulary, provider, buildQuery, providerName, options) {
+  return {
+    vocabulary,
+    countTerm: async (term) => {
+      if (options?.cache) {
+        const cached = options.cache.get(vocabulary, term);
+        if (cached) return cached.found ? 1 : 0;
+      }
+      const query = {
+        native: buildQuery(term),
+        provider: providerName
+      };
+      const count = await provider.count(query);
+      if (options?.cache) {
+        options.cache.set(vocabulary, term, { term, found: count > 0 });
+      }
+      return count;
+    }
+  };
+}
+function createEricCountValidator(provider, options) {
+  return createCountValidator("eric", provider, buildEricCountQuery, "eric", options);
+}
+function createEmtreeCountValidator(provider, options) {
+  return createCountValidator("emtree", provider, buildEmtreeCountQuery, "scopus", options);
+}
+export {
+  createEmtreeCountValidator,
+  createEricCountValidator,
+  extractControlledVocabTerms,
+  validateControlledVocab
+};
+//# sourceMappingURL=vocab-validator.js.map

package/dist/query/vocab-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vocab-validator.js","sources":["../../src/query/vocab-validator.ts"],"sourcesContent":["/**\n * Controlled vocabulary validator.\n *\n * Extracts controlled vocabulary terms (MeSH, etc.) from a QueryAST\n * and validates them against external APIs.\n */\nimport type { QueryAST } from './types.js';\nimport type { MeSHLookupClient, MeSHLookupResult } from './mesh-lookup.js';\nimport type { Provider, ProviderName, TranslatedQuery } from '../providers/base/types.js';\nimport type { VocabCache } from './vocab-cache.js';\n\n/** Supported controlled vocabulary types. */\nexport type VocabType = 'mesh' | 'eric' | 'emtree';\n\n/**\n * A controlled vocabulary term extracted from a QueryAST.\n */\nexport interface VocabTerm {\n  term: string;\n  vocabulary: VocabType;\n}\n\n/**\n * Result of validating a single controlled vocabulary term.\n */\nexport interface VocabTermResult {\n  term: string;\n  vocabulary: VocabType;\n  found: boolean;\n  suggestions?: string[];\n}\n\n/**\n * A controlled vocabulary term that failed due to an API error.\n */\nexport interface VocabTermError {\n  term: string;\n  vocabulary: VocabType;\n  error: string;\n}\n\n/**\n * Result of validating all controlled vocabulary terms in a query.\n */\nexport interface VocabValidationResult {\n  valid: VocabTermResult[];\n  invalid: VocabTermResult[];\n  errors: VocabTermError[];\n}\n\n/**\n * Extract all controlled vocabulary terms from a QueryAST.\n * Terms are deduplicated across blocks.\n */\nexport function extractControlledVocabTerms(ast: QueryAST): VocabTerm[] {\n  const seen = new Set<string>();\n  const terms: VocabTerm[] = [];\n\n  const vocabFields: { key: keyof typeof ast.blocks[0]['terms']; vocab: VocabType }[] = [\n    { key: 'mesh', vocab: 'mesh' },\n    { key: 'eric', vocab: 'eric' },\n    { key: 'emtree', vocab: 'emtree' },\n  ];\n\n  for (const block of ast.blocks) {\n    for (const { key, vocab } of vocabFields) {\n      const fieldTerms = block.terms[key];\n      if (fieldTerms) {\n        for (const term of fieldTerms) {\n          const dedupeKey = `${vocab}:${term}`;\n          if (!seen.has(dedupeKey)) {\n            seen.add(dedupeKey);\n            terms.push({ term, vocabulary: vocab });\n          }\n        }\n      }\n    }\n  }\n\n  return terms;\n}\n\n/**\n * A count-based vocabulary validator.\n * Validates terms by executing a count-only search — hit count 0 means invalid.\n */\nexport interface CountVocabValidator {\n  vocabulary: VocabType;\n  countTerm: (term: string) => Promise<number>;\n}\n\nasync function mapWithConcurrency<T, R>(\n  items: T[],\n  concurrency: number,\n  fn: (item: T) => Promise<R>\n): Promise<R[]> {\n  const results: R[] = [];\n  let index = 0;\n  async function worker() {\n    while (index < items.length) {\n      const i = index++;\n      const item = items[i];\n      if (item !== undefined) results[i] = await fn(item);\n    }\n  }\n  await Promise.all(\n    Array.from({ length: Math.min(concurrency, items.length) }, () => worker())\n  );\n  return results;\n}\n\n/**\n * Validate all controlled vocabulary terms in a QueryAST.\n *\n * MeSH terms are validated via the MeSH lookup API (exact match + suggestions).\n * ERIC/Emtree terms are validated via count-only search when countValidators are provided.\n * Terms whose vocabulary has no validator are skipped silently.\n *\n * Different vocabulary groups are validated in parallel; within each group,\n * concurrency is limited to 3 requests at a time.\n */\nexport async function validateControlledVocab(\n  ast: QueryAST,\n  meshClient: MeSHLookupClient,\n  options?: { countValidators?: CountVocabValidator[] }\n): Promise<VocabValidationResult> {\n  const terms = extractControlledVocabTerms(ast);\n\n  const countValidatorMap = new Map<VocabType, CountVocabValidator>();\n  for (const cv of options?.countValidators ?? []) {\n    countValidatorMap.set(cv.vocabulary, cv);\n  }\n\n  // Group terms by vocabulary\n  const meshTerms = terms.filter((t) => t.vocabulary === 'mesh');\n  const countGroups = new Map<VocabType, VocabTerm[]>();\n  for (const t of terms) {\n    if (t.vocabulary === 'mesh') continue;\n    const validator = countValidatorMap.get(t.vocabulary);\n    if (!validator) continue;\n    const group = countGroups.get(t.vocabulary) ?? [];\n    group.push(t);\n    countGroups.set(t.vocabulary, group);\n  }\n\n  type TermOutcome =\n    | { kind: 'valid'; result: VocabTermResult }\n    | { kind: 'invalid'; result: VocabTermResult }\n    | { kind: 'error'; error: VocabTermError };\n\n  const CONCURRENCY = 3;\n\n  // Validate MeSH terms\n  const meshTask = mapWithConcurrency(meshTerms, CONCURRENCY, async (vocabTerm): Promise<TermOutcome> => {\n    let result: MeSHLookupResult;\n    try {\n      result = await meshClient.lookupTerm(vocabTerm.term);\n    } catch (err) {\n      return {\n        kind: 'error',\n        error: {\n          term: vocabTerm.term,\n          vocabulary: vocabTerm.vocabulary,\n          error: err instanceof Error ? err.message : String(err),\n        },\n      };\n    }\n    const termResult: VocabTermResult = {\n      term: vocabTerm.term,\n      vocabulary: vocabTerm.vocabulary,\n      found: result.found,\n      ...(result.suggestions ? { suggestions: result.suggestions } : {}),\n    };\n    return { kind: result.found ? 'valid' : 'invalid', result: termResult };\n  });\n\n  // Validate count-based vocab groups in parallel\n  const countTasks = [...countGroups.entries()].map(([vocabType, groupTerms]) => {\n    const validator = countValidatorMap.get(vocabType);\n    if (!validator) return Promise.resolve([]);\n    return mapWithConcurrency(groupTerms, CONCURRENCY, async (vocabTerm): Promise<TermOutcome> => {\n      let count: number;\n      try {\n        count = await validator.countTerm(vocabTerm.term);\n      } catch (err) {\n        return {\n          kind: 'error',\n          error: {\n            term: vocabTerm.term,\n            vocabulary: vocabTerm.vocabulary,\n            error: err instanceof Error ? err.message : String(err),\n          },\n        };\n      }\n      const termResult: VocabTermResult = {\n        term: vocabTerm.term,\n        vocabulary: vocabTerm.vocabulary,\n        found: count > 0,\n      };\n      return { kind: count > 0 ? 'valid' : 'invalid', result: termResult };\n    });\n  });\n\n  const allOutcomes = (await Promise.all([meshTask, ...countTasks])).flat();\n\n  const valid: VocabTermResult[] = [];\n  const invalid: VocabTermResult[] = [];\n  const errors: VocabTermError[] = [];\n\n  for (const outcome of allOutcomes) {\n    if (outcome.kind === 'valid') valid.push(outcome.result);\n    else if (outcome.kind === 'invalid') invalid.push(outcome.result);\n    else errors.push(outcome.error);\n  }\n\n  return { valid, invalid, errors };\n}\n\n/**\n * Build a native count-only query for a single ERIC descriptor.\n * Uses subject: field with quoted term.\n */\nfunction buildEricCountQuery(term: string): string {\n  return `subject:\"${term.replace(/\"/g, '')}\"`;\n}\n\n/**\n * Build a native count-only query for a single Emtree term.\n * Uses INDEXTERMS() function with quoted term.\n */\nfunction buildEmtreeCountQuery(term: string): string {\n  return `INDEXTERMS(\"${term.replace(/\"/g, '')}\")`;\n}\n\nfunction createCountValidator(\n  vocabulary: VocabType,\n  provider: Provider,\n  buildQuery: (term: string) => string,\n  providerName: ProviderName,\n  options?: { cache?: VocabCache }\n): CountVocabValidator {\n  return {\n    vocabulary,\n    countTerm: async (term: string): Promise<number> => {\n      if (options?.cache) {\n        const cached = options.cache.get(vocabulary, term);\n        if (cached) return cached.found ? 1 : 0;\n      }\n\n      const query: TranslatedQuery = {\n        native: buildQuery(term),\n        provider: providerName,\n      };\n      const count = await provider.count(query);\n\n      if (options?.cache) {\n        options.cache.set(vocabulary, term, { term, found: count > 0 });\n      }\n\n      return count;\n    },\n  };\n}\n\nexport function createEricCountValidator(\n  provider: Provider,\n  options?: { cache?: VocabCache }\n): CountVocabValidator {\n  return createCountValidator('eric', provider, buildEricCountQuery, 'eric', options);\n}\n\nexport function createEmtreeCountValidator(\n  provider: Provider,\n  options?: { cache?: VocabCache }\n): CountVocabValidator {\n  return createCountValidator('emtree', provider, buildEmtreeCountQuery, 'scopus', options);\n}\n"],"names":[],"mappings":"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"}

package/dist/utils/levenshtein.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Compute the Levenshtein (edit) distance between two strings
+ * using the Wagner-Fischer dynamic programming algorithm.
+ */
+export declare function levenshteinDistance(a: string, b: string): number;
+//# sourceMappingURL=levenshtein.d.ts.map

package/dist/utils/levenshtein.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"levenshtein.d.ts","sourceRoot":"","sources":["../../src/utils/levenshtein.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAgBhE"}

package/dist/utils/levenshtein.js

@@ -0,0 +1,21 @@
+function levenshteinDistance(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        dp[i][j - 1] + 1,
+        dp[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return dp[m][n];
+}
+export {
+  levenshteinDistance
+};
+//# sourceMappingURL=levenshtein.js.map

package/dist/utils/levenshtein.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"levenshtein.js","sources":["../../src/utils/levenshtein.ts"],"sourcesContent":["/**\n * Compute the Levenshtein (edit) distance between two strings\n * using the Wagner-Fischer dynamic programming algorithm.\n */\nexport function levenshteinDistance(a: string, b: string): number {\n  const m = a.length, n = b.length;\n  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));\n  for (let i = 0; i <= m; i++) dp[i]![0] = i;\n  for (let j = 0; j <= n; j++) dp[0]![j] = j;\n  for (let i = 1; i <= m; i++) {\n    for (let j = 1; j <= n; j++) {\n      const cost = a[i - 1] === b[j - 1] ? 0 : 1;\n      dp[i]![j] = Math.min(\n        dp[i - 1]![j]! + 1,\n        dp[i]![j - 1]! + 1,\n        dp[i - 1]![j - 1]! + cost\n      );\n    }\n  }\n  return dp[m]![n]!;\n}\n"],"names":[],"mappings":"AAIO,SAAS,oBAAoB,GAAW,GAAmB;AAChE,QAAM,IAAI,EAAE,QAAQ,IAAI,EAAE;AAC1B,QAAM,KAAiB,MAAM,KAAK,EAAE,QAAQ,IAAI,EAAA,GAAK,MAAM,MAAM,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC;AAC/E,WAAS,IAAI,GAAG,KAAK,GAAG,IAAK,IAAG,CAAC,EAAG,CAAC,IAAI;AACzC,WAAS,IAAI,GAAG,KAAK,GAAG,IAAK,IAAG,CAAC,EAAG,CAAC,IAAI;AACzC,WAAS,IAAI,GAAG,KAAK,GAAG,KAAK;AAC3B,aAAS,IAAI,GAAG,KAAK,GAAG,KAAK;AAC3B,YAAM,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,IAAI;AACzC,SAAG,CAAC,EAAG,CAAC,IAAI,KAAK;AAAA,QACf,GAAG,IAAI,CAAC,EAAG,CAAC,IAAK;AAAA,QACjB,GAAG,CAAC,EAAG,IAAI,CAAC,IAAK;AAAA,QACjB,GAAG,IAAI,CAAC,EAAG,IAAI,CAAC,IAAK;AAAA,MAAA;AAAA,IAEzB;AAAA,EACF;AACA,SAAO,GAAG,CAAC,EAAG,CAAC;AACjB;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ncukondo/search-hub",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "description": "A CLI tool for systematic literature searching across multiple academic databases",
   "type": "module",
   "engines": {