@nice-tools/fake-llm 1.3.0

package/dist/browser.mjs

@@ -0,0 +1,591 @@
+import nlp from 'compromise';
+
+// src/adapters/base.adapter.ts
+var BaseAdapter = class {
+  buildWhereClause(filters) {
+    if (!filters || Object.keys(filters).length === 0) {
+      return "";
+    }
+    const conditions = Object.entries(filters).map(([key, value]) => {
+      if (typeof value === "string") {
+        return `c.${key} = '${value}'`;
+      }
+      return `c.${key} = ${value}`;
+    });
+    return "WHERE " + conditions.join(" AND ");
+  }
+};
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "shall",
+  "should",
+  "may",
+  "might",
+  "must",
+  "can",
+  "could",
+  "let",
+  "make",
+  "why",
+  "what",
+  "how",
+  "when",
+  "where",
+  "who",
+  "which",
+  "that",
+  "this",
+  "these",
+  "those",
+  "it",
+  "its",
+  "my",
+  "your",
+  "his",
+  "her",
+  "our",
+  "their",
+  "me",
+  "him",
+  "us",
+  "them",
+  "and",
+  "or",
+  "but",
+  "if",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "about",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "between",
+  "out",
+  "off",
+  "over",
+  "under",
+  "again",
+  "further",
+  "just",
+  "also",
+  "not",
+  "no",
+  "nor",
+  "so",
+  "yet",
+  "both",
+  "either"
+]);
+var NLPMatcher = class {
+  parseQuery(query) {
+    const cleanQuery = query.replace(/[?!.,;:'"]/g, " ").trim();
+    const doc = nlp(cleanQuery);
+    const action = this.extractAction(query);
+    const keywords = this.extractKeywords(doc, cleanQuery);
+    const filters = this.extractFilters(query);
+    const confidence = keywords.length > 0 ? 0.8 : 0.3;
+    return { action, keywords, filters, confidence };
+  }
+  extractAction(query) {
+    const q = query.toLowerCase();
+    if (q.includes("compare") || q.includes("difference")) return "compare";
+    if (q.includes("diff") || q.includes("what changed")) return "diff";
+    if (q.includes("find") || q.includes("search") || q.includes("which")) return "find";
+    if (q.includes("explain") || q.includes("what is") || q.includes("tell me about") || q.startsWith("why")) return "explain";
+    return "list";
+  }
+  extractKeywords(doc, cleanQuery) {
+    const nouns = doc.nouns().out("array");
+    const adjectives = doc.adjectives().out("array");
+    const allTerms = [];
+    for (const term of [...nouns, ...adjectives]) {
+      const parts = term.toLowerCase().split(/\s+/);
+      allTerms.push(...parts);
+    }
+    const queryWords = cleanQuery.toLowerCase().split(/\s+/);
+    allTerms.push(...queryWords);
+    return [...new Set(allTerms)].map((w) => w.toLowerCase().replace(/[^a-z0-9-]/g, "")).filter((w) => w.length > 2 && !STOP_WORDS.has(w));
+  }
+  extractFilters(query) {
+    const filters = {};
+    const questionWords = /* @__PURE__ */ new Set(["why", "what", "how", "when", "where", "who", "which"]);
+    const pattern = /(?:where|with)\s+(\w+)\s+(?:is|=|equals?)\s+['"]?([^'"\s]+)['"]?/gi;
+    let match;
+    while ((match = pattern.exec(query)) !== null) {
+      const [, key, value] = match;
+      if (key && value && !questionWords.has(key.toLowerCase())) {
+        filters[key] = value;
+      }
+    }
+    return filters;
+  }
+};
+
+// src/engine/keyword-resolver.ts
+var KeywordResolver = class {
+  constructor(keywords) {
+    this.keywords = keywords;
+  }
+  keywords;
+  resolve(term) {
+    const lowerTerm = term.toLowerCase();
+    let match = this.keywords.find((kw) => kw.keyword.toLowerCase() === lowerTerm);
+    if (!match) {
+      match = this.keywords.find(
+        (kw) => kw.aliases.some((alias) => alias.toLowerCase() === lowerTerm)
+      );
+    }
+    if (!match) {
+      match = this.keywords.find(
+        (kw) => kw.keyword.length > 2 && lowerTerm.includes(kw.keyword.toLowerCase())
+      );
+    }
+    return match;
+  }
+  /**
+   * Resolves a list of NLP-extracted terms AND also checks the full original query
+   * against all keyword aliases (to handle multi-word alias phrases).
+   */
+  resolveAll(terms, fullQuery) {
+    const resolved = /* @__PURE__ */ new Map();
+    for (const term of terms) {
+      const kw = this.resolve(term);
+      if (kw) resolved.set(kw.keyword, kw);
+    }
+    if (fullQuery) {
+      const lowerQuery = fullQuery.toLowerCase().replace(/[?!.,;:'"]/g, " ");
+      for (const kw of this.keywords) {
+        if (!resolved.has(kw.keyword)) {
+          const aliasMatch = kw.aliases.some((alias) => {
+            const lowerAlias = alias.toLowerCase();
+            return lowerAlias.length > 3 && lowerQuery.includes(lowerAlias);
+          });
+          if (aliasMatch) resolved.set(kw.keyword, kw);
+        }
+      }
+    }
+    return Array.from(resolved.values());
+  }
+  getRelatedKeywords(keyword) {
+    return this.keywords.filter(
+      (kw) => kw.category === keyword.category && kw.keyword !== keyword.keyword
+    );
+  }
+};
+
+// src/engine/story-resolver.ts
+var STORY_THRESHOLD = 0.1;
+var StoryResolver = class {
+  constructor(stories) {
+    this.stories = stories;
+  }
+  stories;
+  scoreAll(intent, resolvedKeywords) {
+    return this.stories.map((story) => {
+      const score = this.scoreStory(story, intent, resolvedKeywords);
+      const matchedKeywords = resolvedKeywords.filter((kw) => story.keywords.includes(kw.keyword)).map((kw) => kw.keyword);
+      const storyId = story.story_id || story.id || "";
+      return { storyId, score, matchedKeywords, storyKeywords: story.keywords };
+    }).sort((a, b) => b.score - a.score);
+  }
+  findBestStory(intent, resolvedKeywords) {
+    const matches = this.stories.map((story) => {
+      const score = this.scoreStory(story, intent, resolvedKeywords);
+      const matchedKeywords = resolvedKeywords.filter((kw) => story.keywords.includes(kw.keyword)).map((kw) => kw.keyword);
+      return { story, score, matchedKeywords };
+    });
+    matches.sort((a, b) => b.score - a.score);
+    const best = matches[0];
+    return best && best.score > STORY_THRESHOLD ? best : void 0;
+  }
+  scoreStory(story, intent, resolvedKeywords) {
+    let score = 0;
+    const keywordNames = resolvedKeywords.map((kw) => kw.keyword);
+    const overlap = story.keywords.filter((kw) => keywordNames.includes(kw)).length;
+    const keywordScore = overlap / Math.max(story.keywords.length, keywordNames.length, 1);
+    score += keywordScore * 0.7;
+    if (intent.action === "compare" && story.resolution_steps.some((s) => s.action === "compare")) score += 0.2;
+    if (intent.action === "diff" && story.resolution_steps.some((s) => s.action === "diff")) score += 0.2;
+    if (overlap === story.keywords.length) score += 0.1;
+    return Math.min(score, 1);
+  }
+};
+
+// src/engine/query-builder.ts
+var QueryBuilder = class {
+  buildQuery(step, intent) {
+    return {
+      source: step.from_source || "",
+      filters: { ...intent.filters }
+    };
+  }
+  buildQueryPreview(step, intent, resolvedKeywords = []) {
+    const filters = intent.filters || {};
+    const where = Object.entries(filters).map(
+      ([key, value]) => typeof value === "string" ? `c.${key} = '${value}'` : `c.${key} = ${value}`
+    ).join(" AND ");
+    const generatedQuery = where ? `SELECT * FROM c WHERE ${where}` : `SELECT * FROM c /* ${step.from_source || "source"} */`;
+    const terms = [.../* @__PURE__ */ new Set([...step.keyword ? [step.keyword] : [], ...resolvedKeywords])];
+    const searchPattern = terms.length > 0 ? `MATCH ${terms.map((term) => `"${term}"`).join(" OR ")}` : `MATCH ${step.from_source || "source"}*`;
+    return { generatedQuery, searchPattern };
+  }
+  buildSQLWhere(filters) {
+    if (!filters || Object.keys(filters).length === 0) return "";
+    const conditions = Object.entries(filters).map(
+      ([key, value]) => typeof value === "string" ? `c.${key} = '${value}'` : `c.${key} = ${value}`
+    );
+    return "WHERE " + conditions.join(" AND ");
+  }
+};
+
+// src/engine/response-builder.ts
+var ResponseBuilder = class {
+  buildAnswer(intent, story, results, executionTime, source) {
+    return {
+      intent,
+      story,
+      results,
+      summary: this.buildSummary(intent, results),
+      metadata: {
+        execution_time_ms: executionTime,
+        source
+      }
+    };
+  }
+  buildSummary(intent, results) {
+    if (results.length === 0) return "I couldn't find any results for your question.";
+    if (results.length === 1 && results[0]?.answer) {
+      return results[0].answer;
+    }
+    if (intent.action === "explain") {
+      const withAnswer = results.find((r) => r.answer);
+      if (withAnswer) return withAnswer.answer;
+      return Object.entries(results[0]).filter(([key]) => !key.startsWith("_") && key !== "id").map(([key, value]) => `${key}: ${value}`).join(", ");
+    }
+    if (intent.action === "compare") return `Comparing ${results.length} items.`;
+    const answers = results.filter((r) => r.answer).map((r) => r.answer);
+    if (answers.length > 0) return answers.join(" | ");
+    return `Found ${results.length} result(s).`;
+  }
+};
+
+// src/config/fetch-loader.ts
+var FetchConfigLoader = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async loadKeywords() {
+    const response = await fetch(this.options.keywordsUrl);
+    if (!response.ok) {
+      throw new Error(
+        `FetchConfigLoader: Failed to fetch keywords from ${this.options.keywordsUrl} (${response.status})`
+      );
+    }
+    const data = await response.json();
+    return Array.isArray(data) ? data : [data];
+  }
+  async loadStories() {
+    const response = await fetch(this.options.storiesUrl);
+    if (!response.ok) {
+      throw new Error(
+        `FetchConfigLoader: Failed to fetch stories from ${this.options.storiesUrl} (${response.status})`
+      );
+    }
+    const data = await response.json();
+    return Array.isArray(data) ? data : [data];
+  }
+};
+
+// src/adapters/http-mock.adapter.ts
+var HttpMockAdapter = class extends BaseAdapter {
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  options;
+  async query(params) {
+    if (params.source.includes("..") || params.source.startsWith("/") || params.source.includes("://")) {
+      throw new Error(`HttpMockAdapter: Invalid source path '${params.source}'`);
+    }
+    const base = this.options.baseUrl.replace(/\/$/, "");
+    const url = `${base}/${params.source}.json`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      if (response.status === 404) return [];
+      throw new Error(`HttpMockAdapter: Failed to fetch ${url} (${response.status})`);
+    }
+    const data = await response.json();
+    let items = Array.isArray(data) ? data : [data];
+    if (params.filters && Object.keys(params.filters).length > 0) {
+      items = items.filter((item) => this.matchesFilters(item, params.filters));
+    }
+    if (params.limit) {
+      items = items.slice(0, params.limit);
+    }
+    return items;
+  }
+  async getById(_id) {
+    throw new Error("HttpMockAdapter.getById is not supported \u2014 use query() with a filters object");
+  }
+  matchesFilters(item, filters) {
+    return Object.entries(filters).every(([key, value]) => {
+      const itemValue = this.getNestedValue(item, key);
+      return itemValue === value;
+    });
+  }
+  getNestedValue(obj, path) {
+    return path.split(".").reduce((current, key) => current?.[key], obj);
+  }
+};
+
+// src/mock-llm-engine.ts
+var MockLLMEngine = class {
+  constructor(keywords, stories, adapter, fallbackLLM) {
+    this.keywords = keywords;
+    this.stories = stories;
+    this.adapter = adapter;
+    this.fallbackLLM = fallbackLLM;
+    this.nlpMatcher = new NLPMatcher();
+    this.queryBuilder = new QueryBuilder();
+    this.responseBuilder = new ResponseBuilder();
+    this.keywordResolver = new KeywordResolver(keywords);
+    this.storyResolver = new StoryResolver(stories);
+  }
+  keywords;
+  stories;
+  adapter;
+  fallbackLLM;
+  nlpMatcher;
+  keywordResolver;
+  storyResolver;
+  queryBuilder;
+  responseBuilder;
+  // ─── Introspection API ───────────────────────────────────────────────────────
+  getKeywords() {
+    return this.keywords;
+  }
+  getStories() {
+    return this.stories;
+  }
+  listDataSources() {
+    const sources = /* @__PURE__ */ new Set();
+    for (const kw of this.keywords) {
+      if (kw.data_source) sources.add(kw.data_source);
+    }
+    for (const story of this.stories) {
+      if (story.contract?.sources) {
+        for (const source of story.contract.sources) {
+          if (source) sources.add(source);
+        }
+      }
+      for (const step of story.resolution_steps) {
+        if (step.from_source) sources.add(step.from_source);
+      }
+    }
+    return Array.from(sources);
+  }
+  async getDataSourceSnapshot(source, limit = 50) {
+    return this.adapter.query({ source, limit });
+  }
+  // ─── Query ───────────────────────────────────────────────────────────────────
+  async query(userQuery, opts = { debug: true }) {
+    const includeDebug = opts.debug !== false;
+    const startTime = Date.now();
+    const intent = this.nlpMatcher.parseQuery(userQuery);
+    const nlpTerms = intent.keywords;
+    const resolvedKeywords = this.keywordResolver.resolveAll(nlpTerms, userQuery);
+    const unresolvedTerms = nlpTerms.filter(
+      (term) => !resolvedKeywords.some(
+        (kw) => kw.keyword.toLowerCase() === term.toLowerCase() || kw.aliases.some((a) => a.toLowerCase() === term.toLowerCase())
+      )
+    );
+    const storyCandidates = this.storyResolver.scoreAll(intent, resolvedKeywords);
+    const storyMatch = storyCandidates.find((c) => c.score > STORY_THRESHOLD);
+    const matchedStory = storyMatch ? this.stories.find((s) => (s.story_id || s.id) === storyMatch.storyId) : void 0;
+    const debugSteps = [];
+    if (!matchedStory && this.fallbackLLM?.enabled) {
+      const debugInfo = includeDebug ? {
+        rawQuery: userQuery,
+        intent,
+        resolvedKeywords,
+        unresolvedTerms,
+        storyCandidates,
+        selectedStory: void 0,
+        threshold: STORY_THRESHOLD,
+        decision: "no-story-fallback-llm",
+        steps: [],
+        totals: { results: 0, durationMs: Date.now() - startTime }
+      } : void 0;
+      const ans = await this.queryFallbackLLM(userQuery, intent, startTime);
+      if (includeDebug && debugInfo) {
+        debugInfo.totals.durationMs = Date.now() - startTime;
+        debugInfo.decision = ans.metadata.source === "fallback-llm" && ans.results.length > 0 ? "no-story-fallback-llm" : "fallback-llm-error";
+        ans.debug = debugInfo;
+      }
+      return ans;
+    }
+    if (!matchedStory) {
+      const answer2 = this.responseBuilder.buildAnswer(intent, void 0, [], Date.now() - startTime, "mock-llm");
+      if (includeDebug) {
+        answer2.debug = {
+          rawQuery: userQuery,
+          intent,
+          resolvedKeywords,
+          unresolvedTerms,
+          storyCandidates,
+          selectedStory: void 0,
+          threshold: STORY_THRESHOLD,
+          decision: "no-story-no-results",
+          steps: [],
+          totals: { results: 0, durationMs: Date.now() - startTime }
+        };
+      }
+      return answer2;
+    }
+    let results = [];
+    let stepIndex = 0;
+    for (const step of matchedStory.resolution_steps) {
+      if (step.action === "fetch") {
+        const queryParams = this.queryBuilder.buildQuery(step, intent);
+        const builtFilter = this.queryBuilder.buildSQLWhere(queryParams.filters || {});
+        const preview = this.queryBuilder.buildQueryPreview(step, intent, resolvedKeywords.map((kw) => kw.keyword));
+        const data = await this.adapter.query(queryParams);
+        if (includeDebug) {
+          debugSteps.push({
+            step: step.step ?? ++stepIndex,
+            action: step.action,
+            source: queryParams.source,
+            queryParams,
+            builtFilter: builtFilter || `GET ${queryParams.source}/*`,
+            generatedQuery: preview.generatedQuery,
+            searchPattern: preview.searchPattern,
+            rowsReturned: data.length,
+            sampleRows: data.slice(0, 3)
+          });
+        }
+        results = [...results, ...data];
+      }
+    }
+    const answer = this.responseBuilder.buildAnswer(intent, matchedStory, results, Date.now() - startTime, "mock-llm");
+    if (includeDebug) {
+      answer.debug = {
+        rawQuery: userQuery,
+        intent,
+        resolvedKeywords,
+        unresolvedTerms,
+        storyCandidates,
+        selectedStory: { storyId: storyMatch.storyId, score: storyMatch.score },
+        threshold: STORY_THRESHOLD,
+        decision: "matched-story",
+        steps: debugSteps,
+        totals: { results: results.length, durationMs: Date.now() - startTime }
+      };
+    }
+    return answer;
+  }
+  async queryFallbackLLM(userQuery, intent, startTime) {
+    const llmConfig = this.fallbackLLM;
+    try {
+      const response = await fetch(llmConfig.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${llmConfig.apiKey}`
+        },
+        body: JSON.stringify({
+          model: llmConfig.model,
+          messages: [{ role: "user", content: userQuery }]
+        })
+      });
+      const data = await response.json();
+      const llmAnswer = data.choices?.[0]?.message?.content || "No response from LLM";
+      return {
+        intent,
+        story: void 0,
+        results: [{ answer: llmAnswer }],
+        summary: llmAnswer,
+        metadata: { execution_time_ms: Date.now() - startTime, source: "fallback-llm" }
+      };
+    } catch (error) {
+      return {
+        intent,
+        story: void 0,
+        results: [],
+        summary: `Fallback LLM error: ${error.message}`,
+        metadata: { execution_time_ms: Date.now() - startTime, source: "fallback-llm" }
+      };
+    }
+  }
+};
+
+// src/browser-mock-llm.ts
+var BrowserMockLLM = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  engine;
+  async initialize() {
+    const loader = new FetchConfigLoader({
+      keywordsUrl: this.options.keywordsUrl,
+      storiesUrl: this.options.storiesUrl
+    });
+    const [keywords, stories] = await Promise.all([
+      loader.loadKeywords(),
+      loader.loadStories()
+    ]);
+    const adapter = new HttpMockAdapter({ baseUrl: this.options.dataBaseUrl });
+    const fallbackLLM = this.options.fallbackLLM?.enabled ? this.options.fallbackLLM : void 0;
+    this.engine = new MockLLMEngine(keywords, stories, adapter, fallbackLLM);
+  }
+  // ─── Introspection API (mirrors MockLLM) ─────────────────────────────────────
+  getKeywords() {
+    return this.engine.getKeywords();
+  }
+  getStories() {
+    return this.engine.getStories();
+  }
+  listDataSources() {
+    return this.engine.listDataSources();
+  }
+  async getDataSourceSnapshot(source, limit = 50) {
+    return this.engine.getDataSourceSnapshot(source, limit);
+  }
+  // ─── Query ───────────────────────────────────────────────────────────────────
+  async query(userQuery, opts = { debug: true }) {
+    return this.engine.query(userQuery, opts);
+  }
+};
+
+export { BaseAdapter, BrowserMockLLM, FetchConfigLoader, HttpMockAdapter, KeywordResolver, MockLLMEngine, NLPMatcher, QueryBuilder, ResponseBuilder, STORY_THRESHOLD, StoryResolver };
+//# sourceMappingURL=browser.mjs.map
+//# sourceMappingURL=browser.mjs.map