@adityanair98/api-oracle 0.5.0 → 0.6.0

package/dist/knowledge/search.js

@@ -1,105 +1,108 @@
 /**
- * Search layer — combines SQLite text search with the scoring engine.
- * Uses synonym expansion and category detection to improve result quality.
+ * Search layer — scores the knowledge base against a task and keeps only
+ * candidates that are actually relevant to it.
  *
- * Exports: SearchConstraints, RankedResult, findApis, getApiBySlug, getApisByCategory
+ * Exports: SearchConstraints, RankedResult, SearchOutcome, RELEVANCE_GATE,
+ *          findApis, findApisDetailed, getApiBySlug, getApisByCategory
  */
 import { getAllEntries, getBySlug, getByCategory } from "./db.js";
 import { rankEntries, computeConfidence, confidenceLabel } from "./scorer.js";
+import { buildRelevanceModel } from "./relevance.js";
 import { expandQuery, detectCategory, detectPhrases } from "./synonyms.js";
 import { getTfIdfEngine } from "./tfidf.js";
 import { createLogger } from "../utils/logger.js";
 const logger = createLogger("search");
 /**
- * Find and rank APIs for a given task description.
- *
- * Pipeline:
- * 1. Detect phrases (preferFree, open source, etc.) — merge with constraints
- * 2. Expand query with synonyms
- * 3. SQLite text search on the expanded query (broader candidate pool)
- * 4. Also text-search on original query (catches exact matches)
- * 5. Detect category for scoring boost
- * 6. Rank all candidates with scorer using expanded query + context
+ * Relevance gate. A candidate is kept only if:
+ *  - relevance ≥ minAbsolute, and
+ *  - relevance ≥ minRelativeToBest × the best candidate's relevance, and
+ *  - it is not in a clearly unrelated category (categoryFit at its floor while
+ *    the category was detected with ≥ strongCategoryConfidence) unless its own
+ *    relevance is ≥ categoryOverride.
  */
-export function findApis(query, constraints, topN = 3) {
-    logger.debug("findApis called", { query, constraints, topN });
+export const RELEVANCE_GATE = {
+    minAbsolute: 0.2,
+    minRelativeToBest: 0.6,
+    strongCategoryConfidence: 0.5,
+    categoryOverride: 0.6,
+};
+/** Above this many entries, use the TF-IDF index to pre-select candidates */
+const SCORE_ALL_ENTRIES_UP_TO = 500;
+/**
+ * Find and rank APIs for a task, with stats. Pipeline:
+ * 1. Phrase detection (e.g. "free" → preferFree) merged with constraints
+ * 2. Category detection
+ * 3. Candidate pool: every entry (small KB) or TF-IDF + detected category
+ * 4. Score: relevance × bounded quality/DX/pricing/recency prior
+ * 5. Gate: drop candidates that are not relevant enough (RELEVANCE_GATE)
+ */
+export function findApisDetailed(query, constraints, topN = 3) {
+    const empty = { results: [], relevant: [], evaluated: 0, detectedCategory: null };
     if (!query || query.trim().length === 0) {
         logger.warn("Empty query provided to findApis");
-        return [];
+        return empty;
     }
     const trimmedQuery = query.trim();
-    // Step 1: Phrase detection — auto-apply preferFree from query language
     const phrases = detectPhrases(trimmedQuery);
     const effectiveConstraints = {
         ...constraints,
         preferFree: constraints?.preferFree ?? phrases.preferFree,
     };
-    // Step 2: Synonym expansion
-    const expandedQuery = expandQuery(trimmedQuery);
-    logger.debug("Query expanded", {
-        original: trimmedQuery,
-        expanded: expandedQuery.length > trimmedQuery.length
-            ? `${expandedQuery.slice(0, 80)}...`
-            : "unchanged",
-    });
-    // Step 3: Category detection for scoring context
     const { category: detectedCategory, confidence: detectedConfidence } = detectCategory(trimmedQuery);
-    logger.debug("Category detected", { detectedCategory, detectedConfidence });
-    const scoringContext = {
-        expandedQuery,
-        detectedCategory,
-        detectedConfidence,
-    };
-    // Step 4: Build candidate pool via TF-IDF index
-    // Lazily build the index from all entries on first call
     const all = getAllEntries();
-    const engine = getTfIdfEngine();
-    if (!engine.isBuilt) {
-        engine.build(all);
-        logger.debug("TF-IDF index built", { entryCount: engine.size });
-    }
-    // TF-IDF search on expanded query (broader recall than LIKE)
-    const tfIdfCandidates = engine.search(expandedQuery, topN * 8);
-    let candidates = tfIdfCandidates;
-    const seenSlugs = new Set(candidates.map((e) => e.slug));
-    // Also include all entries in the detected category (high-signal candidates)
-    if (detectedCategory && detectedConfidence >= 0.4) {
-        const categoryEntries = getByCategory(detectedCategory);
-        for (const entry of categoryEntries) {
-            if (!seenSlugs.has(entry.slug)) {
-                candidates.push(entry);
-                seenSlugs.add(entry.slug);
+    let pool = all;
+    if (all.length > SCORE_ALL_ENTRIES_UP_TO) {
+        const engine = getTfIdfEngine();
+        if (!engine.isBuilt)
+            engine.build(all);
+        pool = engine.search(expandQuery(trimmedQuery), 100);
+        const seen = new Set(pool.map((e) => e.slug));
+        if (detectedCategory) {
+            for (const e of getByCategory(detectedCategory)) {
+                if (!seen.has(e.slug))
+                    pool.push(e);
             }
         }
     }
-    // Safety net: if still fewer candidates than requested, add remaining entries
-    if (candidates.length < topN) {
-        logger.debug("Broadening to all entries — too few TF-IDF candidates", {
-            candidateCount: candidates.length,
-        });
-        for (const entry of all) {
-            if (!seenSlugs.has(entry.slug)) {
-                candidates.push(entry);
-                seenSlugs.add(entry.slug);
-            }
-        }
-    }
-    // Step 5: Rank with scorer using expanded query + context
-    const results = rankEntries(candidates, trimmedQuery, effectiveConstraints, topN, undefined, scoringContext);
-    // Step 6: Attach confidence to top result
-    if (results.length > 0 && results[0]) {
-        const conf = computeConfidence(results[0], detectedCategory, detectedConfidence, results);
+    if (pool.length === 0)
+        return { ...empty, detectedCategory };
+    const context = {
+        detectedCategory,
+        detectedConfidence,
+        relevanceModel: buildRelevanceModel(trimmedQuery, pool),
+    };
+    const scored = rankEntries(pool, trimmedQuery, effectiveConstraints, pool.length, undefined, context);
+    const bestRelevance = Math.max(0, ...scored.map((r) => r.relevance ?? 0));
+    const strongCategory = detectedCategory !== null && detectedConfidence >= RELEVANCE_GATE.strongCategoryConfidence;
+    const relevant = scored.filter((r) => {
+        const rel = r.relevance ?? 0;
+        if (rel < RELEVANCE_GATE.minAbsolute)
+            return false;
+        if (rel < RELEVANCE_GATE.minRelativeToBest * bestRelevance)
+            return false;
+        const unrelatedCategory = (r.scoreBreakdown["categoryFit"] ?? 1) <= 0.7;
+        if (strongCategory && unrelatedCategory && rel < RELEVANCE_GATE.categoryOverride)
+            return false;
+        return true;
+    });
+    const results = relevant.slice(0, topN);
+    if (results[0]) {
+        const conf = computeConfidence(results[0], detectedCategory, detectedConfidence, relevant);
         results[0].confidence = conf;
         results[0].confidenceLabel = confidenceLabel(conf);
     }
     logger.debug("findApis results", {
-        candidateCount: candidates.length,
-        resultCount: results.length,
-        topSlug: results[0]?.entry.slug,
-        confidence: results[0]?.confidence,
+        query: trimmedQuery,
+        evaluated: pool.length,
+        relevant: relevant.length,
+        top: results.map((r) => `${r.entry.slug}:${r.score.toFixed(2)}`),
         detectedCategory,
     });
-    return results;
+    return { results, relevant, evaluated: pool.length, detectedCategory };
+}
+/** Find and rank APIs for a task — relevant results only, best first. */
+export function findApis(query, constraints, topN = 3) {
+    return findApisDetailed(query, constraints, topN).results;
 }
 /** Get a single API entry by its slug */
 export function getApiBySlug(slug) {

package/dist/knowledge/synonyms.d.ts

@@ -14,6 +14,15 @@ export declare const SYNONYM_GROUPS: readonly string[][];
  *           login signin signup register sso oauth identity..."
  */
 export declare function expandQuery(query: string): string;
+/**
+ * Which synonym groups a query triggers, and which term in the query
+ * triggered each one (same matching rules as expandQuery).
+ * Used by the relevance model to attach synonyms to the query word they expand.
+ */
+export declare function matchSynonymGroups(query: string): Array<{
+    term: string;
+    group: readonly string[];
+}>;
 export interface PhraseModifiers {
     /** User wants free or cheap options */
     preferFree: boolean;

package/dist/knowledge/synonyms.js

@@ -229,6 +229,27 @@ export function expandQuery(query) {
         return query;
     return `${query} ${[...addedTerms].join(" ")}`;
 }
+/**
+ * Which synonym groups a query triggers, and which term in the query
+ * triggered each one (same matching rules as expandQuery).
+ * Used by the relevance model to attach synonyms to the query word they expand.
+ */
+export function matchSynonymGroups(query) {
+    if (!query)
+        return [];
+    const lowerQuery = query.toLowerCase();
+    const matches = [];
+    const seen = new Set();
+    for (const [term, group] of SORTED_TERM_ENTRIES) {
+        if (seen.has(group))
+            continue;
+        if (buildTermRegex(term).test(lowerQuery)) {
+            seen.add(group);
+            matches.push({ term, group });
+        }
+    }
+    return matches;
+}
 const FREE_PATTERNS = [
     /\bfree\b/i, /\bcheap/i, /\bno cost\b/i, /\bbudget\b/i, /\baffordable\b/i,
 ];
@@ -284,8 +305,8 @@ const CATEGORY_DETECTORS = [
     {
         category: "email",
         patterns: [
-            /\bemail\b/i, /\bmail\b/i, /\bsmtp\b/i, /\bnewsletter\b/i,
-            /\binbox\b/i, /\btransactional\b/i, /\bsend.*mail\b/i,
+            /\bemails?\b/i, /\bmails?\b/i, /\bsmtp\b/i, /\bnewsletters?\b/i,
+            /\binbox\b/i, /\btransactional\b/i, /\bsend.*mails?\b/i,
         ],
         weight: 0.4,
     },

package/dist/server.d.ts

@@ -2,8 +2,10 @@
  * MCP server setup — creates the server, registers all tools, and handles protocol.
  * Uses @modelcontextprotocol/sdk McpServer (high-level API).
  *
- * Exports: createServer
+ * Exports: createServer, startServer, SERVER_VERSION
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/** Server version reported to MCP clients — always package.json's version */
+export declare const SERVER_VERSION: string;
 export declare function createServer(): McpServer;
 export declare function startServer(): Promise<void>;

package/dist/server.js

@@ -2,8 +2,9 @@
  * MCP server setup — creates the server, registers all tools, and handles protocol.
  * Uses @modelcontextprotocol/sdk McpServer (high-level API).
  *
- * Exports: createServer
+ * Exports: createServer, startServer, SERVER_VERSION
  */
+import { createRequire } from "module";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { registerFindBestApi } from "./tools/find-api.js";
@@ -12,10 +13,15 @@ import { registerGetSetupGuide } from "./tools/get-setup-guide.js";
 import { registerCheckApiFreshness } from "./tools/check-freshness.js";
 import { createLogger } from "./utils/logger.js";
 const logger = createLogger("server");
+// package.json sits one level above both src/server.ts and dist/server.js
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+/** Server version reported to MCP clients — always package.json's version */
+export const SERVER_VERSION = pkg.version;
 export function createServer() {
     const server = new McpServer({
         name: "api-oracle",
-        version: "0.1.0",
+        version: SERVER_VERSION,
     }, {
         capabilities: {
             tools: {},

package/dist/tools/check-freshness.js

@@ -37,7 +37,7 @@ export function registerCheckApiFreshness(server) {
                     content: [
                         {
                             type: "text",
-                            text: "No entries found in the database. Run `npm run seed` first.",
+                            text: "The knowledge base is empty: no bundled entries were loaded at startup. Check the server's stderr for 'Skipped invalid entry' or 'Knowledge base is empty' messages.",
                         },
                     ],
                 };

package/dist/tools/find-api.d.ts

@@ -3,7 +3,24 @@
  * Finds and recommends the best API for a given task description.
  * Returns a structured recommendation with quick-start code.
  *
- * Exports: registerFindBestApi
+ * Exports: registerFindBestApi, buildFindBestApiResponse, MAX_CANDIDATES
  */
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type SearchConstraints } from "../knowledge/search.js";
+/** Max entries in the `candidates` field */
+export declare const MAX_CANDIDATES = 5;
+/**
+ * Build the find_best_api response body.
+ *
+ * Shape (backward compatible with v0.5.0, plus `candidates`):
+ *   recommendation  — top result with quick-start code
+ *   alternatives    — results 2..3
+ *   candidates      — up to 5 relevant entries with key facts and their
+ *                     relevance, so the calling model can make the final call
+ *   totalEvaluated  — number of knowledge-base entries scored for this query
+ * Every entry carries lastVerified; the recommendation also carries
+ * freshness {lastVerified, daysSinceVerified, level} and a freshnessNote
+ * when it is not fresh.
+ */
+export declare function buildFindBestApiResponse(task: string, constraints?: SearchConstraints): Record<string, unknown>;
 export declare function registerFindBestApi(server: McpServer): void;

package/dist/tools/find-api.js

@@ -3,10 +3,11 @@
  * Finds and recommends the best API for a given task description.
  * Returns a structured recommendation with quick-start code.
  *
- * Exports: registerFindBestApi
+ * Exports: registerFindBestApi, buildFindBestApiResponse, MAX_CANDIDATES
  */
 import { z } from "zod";
-import { findApis } from "../knowledge/search.js";
+import { findApisDetailed } from "../knowledge/search.js";
+import { checkStaleness } from "../updater/staleness.js";
 import { createLogger } from "../utils/logger.js";
 const logger = createLogger("tool:find-api");
 const inputSchema = {
@@ -29,70 +30,115 @@ const inputSchema = {
         .optional()
         .describe("Optional constraints to filter recommendations"),
 };
+/** Max entries in the `candidates` field */
+export const MAX_CANDIDATES = 5;
+function pricingSummary(entry) {
+    return ([
+        entry.pricing.freeTier ? `Free: ${entry.pricing.freeTier}` : null,
+        entry.pricing.startingPrice ? `Paid from ${entry.pricing.startingPrice}` : null,
+        entry.pricing.model === "usage_based" ? "Usage-based (no monthly fee)" : null,
+    ]
+        .filter(Boolean)
+        .join(" | ") || entry.pricing.model);
+}
+/**
+ * lastVerified plus how stale that is. Dates are never changed automatically:
+ * an entry is only "fresh" if a human re-verified it within 90 days.
+ */
+function freshness(entry) {
+    const s = checkStaleness(entry);
+    return { lastVerified: s.lastVerified, daysSinceVerified: s.daysSinceVerified, level: s.level };
+}
+function freshnessNote(f) {
+    return (`This entry was last verified on ${f.lastVerified} (${f.daysSinceVerified} days ago). ` +
+        "Pricing, rate limits and SDK details may have changed since — confirm them on the provider's pricing and docs pages.");
+}
+/**
+ * Build the find_best_api response body.
+ *
+ * Shape (backward compatible with v0.5.0, plus `candidates`):
+ *   recommendation  — top result with quick-start code
+ *   alternatives    — results 2..3
+ *   candidates      — up to 5 relevant entries with key facts and their
+ *                     relevance, so the calling model can make the final call
+ *   totalEvaluated  — number of knowledge-base entries scored for this query
+ * Every entry carries lastVerified; the recommendation also carries
+ * freshness {lastVerified, daysSinceVerified, level} and a freshnessNote
+ * when it is not fresh.
+ */
+export function buildFindBestApiResponse(task, constraints) {
+    const outcome = findApisDetailed(task, constraints, 3);
+    const results = outcome.results;
+    if (results.length === 0) {
+        return {
+            error: "No matching APIs found",
+            suggestion: "Try a broader task description, or the API category may not be in the database yet.",
+            totalEvaluated: outcome.evaluated,
+            candidates: [],
+        };
+    }
+    const [top, ...alternatives] = results;
+    const entry = top.entry;
+    const bestExample = entry.codeExamples[0];
+    const topFreshness = freshness(entry);
+    return {
+        recommendation: {
+            name: entry.name,
+            slug: entry.slug,
+            why: `${entry.bestFor}. ${entry.qualityJustification}`,
+            qualityScore: entry.qualityScore,
+            confidence: top.confidence ?? null,
+            confidenceLabel: top.confidenceLabel ?? null,
+            scoreBreakdown: top.scoreBreakdown,
+            quickStart: {
+                install: entry.sdk.installCommand,
+                envVar: `${entry.auth.envVarName}=your_key_here`,
+                authSnippet: entry.auth.codeSnippet,
+                codeExample: bestExample?.code ?? "See documentation",
+                codeExampleTitle: bestExample?.title ?? "",
+                notes: bestExample?.notes ?? "",
+            },
+            gotchas: entry.gotchas,
+            pricing: pricingSummary(entry),
+            website: entry.website,
+            rateLimitNote: `${entry.rateLimits.tier}: ${entry.rateLimits.limit}`,
+            lastVerified: entry.lastVerified,
+            freshness: topFreshness,
+            ...(topFreshness.level === "fresh" ? {} : { freshnessNote: freshnessNote(topFreshness) }),
+        },
+        alternatives: alternatives.map((r) => ({
+            name: r.entry.name,
+            slug: r.entry.slug,
+            why: r.entry.bestFor,
+            qualityScore: r.entry.qualityScore,
+            score: Math.round(r.score * 100) / 100,
+            lastVerified: r.entry.lastVerified,
+        })),
+        candidates: outcome.relevant.slice(0, MAX_CANDIDATES).map((r) => ({
+            slug: r.entry.slug,
+            name: r.entry.name,
+            category: r.entry.category,
+            bestFor: r.entry.bestFor,
+            relevance: Math.round((r.relevance ?? 0) * 100) / 100,
+            score: Math.round(r.score * 100) / 100,
+            qualityScore: r.entry.qualityScore,
+            pricing: pricingSummary(r.entry),
+            pricingModel: r.entry.pricing.model,
+            primaryLanguage: r.entry.sdk.primaryLanguage,
+            authMethod: r.entry.auth.method,
+            topGotcha: r.entry.gotchas[0] ?? null,
+            website: r.entry.website,
+            lastVerified: r.entry.lastVerified,
+            freshnessLevel: freshness(r.entry).level,
+        })),
+        totalEvaluated: outcome.evaluated,
+    };
+}
 export function registerFindBestApi(server) {
-    server.tool("find_best_api", "Find and recommend the best API for a programming task. Returns top recommendation with quick-start code, gotchas, and alternatives.", inputSchema, async ({ task, constraints }) => {
+    server.tool("find_best_api", "Find and recommend the best API for a programming task. Returns a top recommendation with quick-start code, gotchas and alternatives, plus `candidates`: up to 5 relevant APIs with key facts and relevance scores so you can make the final choice for the user's context.", inputSchema, async ({ task, constraints }) => {
         logger.info("find_best_api called", { task, constraints });
         try {
-            const results = findApis(task, constraints, 3);
-            if (results.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                error: "No matching APIs found",
-                                suggestion: "Try a broader task description, or the API category may not be in the database yet.",
-                                totalEvaluated: 0,
-                            }),
-                        },
-                    ],
-                };
-            }
-            const [top, ...alternatives] = results;
-            const entry = top.entry;
-            // Build a one-line pricing summary
-            const pricingSummary = [
-                entry.pricing.freeTier ? `Free: ${entry.pricing.freeTier}` : null,
-                entry.pricing.startingPrice
-                    ? `Paid from ${entry.pricing.startingPrice}`
-                    : null,
-                entry.pricing.model === "usage_based" ? "Usage-based (no monthly fee)" : null,
-            ]
-                .filter(Boolean)
-                .join(" | ") || entry.pricing.model;
-            // Select best code example — prefer the first one
-            const bestExample = entry.codeExamples[0];
-            const response = {
-                recommendation: {
-                    name: entry.name,
-                    slug: entry.slug,
-                    why: `${entry.bestFor}. ${entry.qualityJustification}`,
-                    qualityScore: entry.qualityScore,
-                    confidence: top.confidence ?? null,
-                    confidenceLabel: top.confidenceLabel ?? null,
-                    scoreBreakdown: top.scoreBreakdown,
-                    quickStart: {
-                        install: entry.sdk.installCommand,
-                        envVar: `${entry.auth.envVarName}=your_key_here`,
-                        authSnippet: entry.auth.codeSnippet,
-                        codeExample: bestExample?.code ?? "See documentation",
-                        codeExampleTitle: bestExample?.title ?? "",
-                        notes: bestExample?.notes ?? "",
-                    },
-                    gotchas: entry.gotchas,
-                    pricing: pricingSummary,
-                    website: entry.website,
-                    rateLimitNote: `${entry.rateLimits.tier}: ${entry.rateLimits.limit}`,
-                },
-                alternatives: alternatives.map((r) => ({
-                    name: r.entry.name,
-                    slug: r.entry.slug,
-                    why: r.entry.bestFor,
-                    qualityScore: r.entry.qualityScore,
-                    score: Math.round(r.score * 100) / 100,
-                })),
-                totalEvaluated: results.length + alternatives.length,
-            };
+            const response = buildFindBestApiResponse(task, constraints);
             return {
                 content: [
                     {

package/dist/utils/config.d.ts

@@ -4,6 +4,7 @@
  * Exports: config (singleton config object)
  */
 export interface Config {
+    /** ":memory:" unless DB_PATH is set explicitly */
     dbPath: string;
     logLevel: string;
     nodeEnv: string;

package/dist/utils/config.js

@@ -4,8 +4,11 @@
  * Exports: config (singleton config object)
  */
 function loadConfig() {
+    const explicitDbPath = process.env["DB_PATH"]?.trim();
     return {
-        dbPath: process.env["DB_PATH"] ?? "./data/api-oracle.db",
+        // Default: in-memory DB loaded from the bundled entries at startup, so
+        // nothing is written to the user's working directory.
+        dbPath: explicitDbPath ? explicitDbPath : ":memory:",
         logLevel: process.env["LOG_LEVEL"] ?? "info",
         nodeEnv: process.env["NODE_ENV"] ?? "development",
     };

package/dist/utils/logger.d.ts

@@ -2,8 +2,15 @@
  * Simple structured logger — no external dependencies.
  * Writes to stderr so MCP stdout stays clean for protocol messages.
  *
- * Exports: logger (default instance), createLogger
+ * Exports: logger (default instance), createLogger, currentLogLevel
+ * Respects LOG_LEVEL (default: info).
  */
+type LogLevel = "debug" | "info" | "warn" | "error";
+/**
+ * Minimum level to emit, from LOG_LEVEL (debug | info | warn | error).
+ * Read on each call so it can be changed at runtime/tests. Default: info.
+ */
+export declare function currentLogLevel(): LogLevel;
 declare function createLogger(namespace: string): {
     debug: (message: string, data?: unknown) => void;
     info: (message: string, data?: unknown) => void;

package/dist/utils/logger.js

@@ -2,7 +2,8 @@
  * Simple structured logger — no external dependencies.
  * Writes to stderr so MCP stdout stays clean for protocol messages.
  *
- * Exports: logger (default instance), createLogger
+ * Exports: logger (default instance), createLogger, currentLogLevel
+ * Respects LOG_LEVEL (default: info).
  */
 function formatEntry(entry) {
     const base = `[${entry.timestamp}] [${entry.level.toUpperCase()}] ${entry.message}`;
@@ -11,8 +12,19 @@ function formatEntry(entry) {
     }
     return base;
 }
+const LEVEL_ORDER = { debug: 10, info: 20, warn: 30, error: 40 };
+/**
+ * Minimum level to emit, from LOG_LEVEL (debug | info | warn | error).
+ * Read on each call so it can be changed at runtime/tests. Default: info.
+ */
+export function currentLogLevel() {
+    const raw = (process.env["LOG_LEVEL"] ?? "info").trim().toLowerCase();
+    return raw in LEVEL_ORDER ? raw : "info";
+}
 function createLogger(namespace) {
     function log(level, message, data) {
+        if (LEVEL_ORDER[level] < LEVEL_ORDER[currentLogLevel()])
+            return;
         const entry = {
             level,
             message: namespace ? `[${namespace}] ${message}` : message,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adityanair98/api-oracle",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "MCP server that finds, evaluates, and recommends the best API for any programming task",
   "type": "module",
   "main": "dist/index.js",
@@ -25,7 +25,7 @@
   },
   "license": "MIT",
   "scripts": {
-    "build": "tsc && cp -r src/dashboard/public dist/dashboard/public",
+    "build": "rm -rf dist && tsc && cp -r src/dashboard/public dist/dashboard/public",
     "dev": "tsx src/index.ts",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -33,11 +33,12 @@
     "seed": "tsx scripts/seed-db.ts",
     "e2e": "tsx scripts/e2e-test.ts",
     "analyze": "tsx scripts/scoring-analysis.ts",
+    "eval": "tsx scripts/eval.ts",
     "refresh-report": "tsx scripts/refresh-report.ts",
     "lint-entries": "tsx scripts/lint-entries.ts",
     "dashboard": "tsx src/dashboard/server.ts",
     "dashboard:dev": "tsx watch src/dashboard/server.ts",
-    "prepublishOnly": "npm run build && npm test"
+    "prepublishOnly": "node -e \"if(/FILL_ME_/.test(require('fs').readFileSync('README.md','utf8'))){console.error('README.md still has FILL_ME_ placeholders');process.exit(1)}\" && npm run build && npm test"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.27.1",