@deerdesign/deertools 1.2.27 → 1.2.32

package/src/skill-commands.js

@@ -6,6 +6,7 @@ const skillsHub = require('./skills-hub');
 const { parseFrontmatterName } = require('./openapi');
 const { resolveProducts } = require('./registry');
 const { fetchText } = require('./http');
+const embedding = require('./embedding');
 
 const { compareSemver } = require('./updater');
 
@@ -269,22 +270,142 @@ function inspectSkillForAgents(agents, skill, lock) {
   };
 }
 
+/**
+ * Sprawdza czy dany skill pasuje do zapytania tekstowego.
+ * Przeszukuje kompleksowo:
+ *  1. Nazwę (slug, full_slug, title)
+ *  2. Opis (summary / description - pełny tekst opisu z SKILL.md)
+ *  3. Tagi (zarówno całe tagi, jak i dopasowania cząstkowe, np. 'matrycowy' w 'cennik-matrycowy')
+ *  4. Kategorie (nazwa kategorii oraz jej slug)
+ *  5. Namespace oraz autora (owner_name, owner_email)
+ */
+function matchSkillQuery(skill, query) {
+  if (!query) return true;
+  const q = String(query).toLowerCase().trim();
+  if (!q) return true;
+
+  // 1. Nazwa, slug, full_slug, title
+  if (skill.slug && String(skill.slug).toLowerCase().includes(q)) return true;
+  if (skill.full_slug && String(skill.full_slug).toLowerCase().includes(q)) return true;
+  if (skill.title && String(skill.title).toLowerCase().includes(q)) return true;
+
+  // 2. Opis (summary / description)
+  if (skill.summary && String(skill.summary).toLowerCase().includes(q)) return true;
+  if (skill.description && String(skill.description).toLowerCase().includes(q)) return true;
+
+  // 3. Tagi (zarówno dopasowanie pełne, jak i podciąg wewnątrz tagu)
+  if (Array.isArray(skill.tags)) {
+    for (const tag of skill.tags) {
+      if (String(tag).toLowerCase().includes(q)) return true;
+    }
+  }
+
+  // 4. Kategoria
+  if (skill.categories) {
+    if (skill.categories.name && String(skill.categories.name).toLowerCase().includes(q)) return true;
+    if (skill.categories.slug && String(skill.categories.slug).toLowerCase().includes(q)) return true;
+  }
+  if (skill.category && typeof skill.category === 'string' && skill.category.toLowerCase().includes(q)) return true;
+
+  // 5. Namespace i właściciel
+  if (skill.namespace && String(skill.namespace).toLowerCase().includes(q)) return true;
+  if (skill.owner_name && String(skill.owner_name).toLowerCase().includes(q)) return true;
+  if (skill.owner_email && String(skill.owner_email).toLowerCase().includes(q)) return true;
+
+  return false;
+}
+
 async function cmdSkillList(flags, out, err) {
-  if (!flags.json) out('Pobieram listę skilli z DeerSkills Hub...');
-  const res = await skillsHub.listSkills({
-    query: flags.query,
-    tag: flags.tag,
-    category: flags.category,
-    scope: flags.scope,
-    limit: flags.limit || 100,
-  });
+  const searchQuery = flags.query ? String(flags.query).trim() : '';
+  const isSearch = Boolean(searchQuery);
 
-  if (!res.ok) {
-    err(`✗ Błąd pobierania skilli (${res.status}): ${res.data?.error || 'Brak dostępu'}`);
-    return;
+  if (!flags.json) {
+    if (isSearch) {
+      out(`Wyszukuję skille w DeerSkills Hub dla frazy „${searchQuery}” (hybrydowo: wektory + tekst)...`);
+    } else {
+      out('Pobieram listę skilli z DeerSkills Hub...');
+    }
+  }
+
+  let items = [];
+
+  if (isSearch) {
+    // 1. Serwerowe wyszukiwanie wektorowo-hybrydowe (PostgreSQL pgvector + trigram + keyword boost)
+    let queryEmbedding = null;
+    if (flags.semantic) {
+      if (!flags.json) out('Generuję wektor semantyczny zapytania...');
+      queryEmbedding = embedding.computeEmbedding(searchQuery);
+    }
+
+    const hybridRes = await skillsHub.searchSkillsHybrid({
+      queryText: searchQuery,
+      queryEmbedding,
+      threshold: queryEmbedding ? 0.1 : 0.05,
+      count: flags.limit || 50,
+    });
+
+    if (hybridRes.ok && Array.isArray(hybridRes.data)) {
+      items = hybridRes.data;
+
+      // 2. Jeśli zapytanie tekstowe dało 0 wyników, a dostępne jest lokalne generowanie wektorów — ponów semantycznie
+      if (items.length === 0 && !flags.semantic && embedding.isEmbeddingAvailable()) {
+        const autoEmb = embedding.computeEmbedding(searchQuery);
+        if (autoEmb) {
+          const semRes = await skillsHub.searchSkillsHybrid({
+            queryText: searchQuery,
+            queryEmbedding: autoEmb,
+            threshold: 0.12,
+            count: flags.limit || 50,
+          });
+          if (semRes.ok && Array.isArray(semRes.data) && semRes.data.length > 0) {
+            items = semRes.data;
+          }
+        }
+      }
+
+      if (flags.tag) {
+        items = items.filter((s) => Array.isArray(s.tags) && s.tags.includes(flags.tag));
+      }
+      if (flags.category) {
+        const cat = String(flags.category).toLowerCase();
+        items = items.filter((s) => s.category_slug === cat || (s.category_name && s.category_name.toLowerCase().includes(cat)));
+      }
+      if (flags.scope) {
+        items = items.filter((s) => s.scope === flags.scope);
+      }
+    } else {
+      // Fallback do pobierania pełnej listy i lokalnego przeszukiwania
+      const res = await skillsHub.listSkills({
+        tag: flags.tag,
+        category: flags.category,
+        scope: flags.scope,
+        limit: flags.limit || 200,
+      });
+
+      if (!res.ok) {
+        err(`✗ Błąd pobierania skilli (${res.status}): ${res.data?.error || 'Brak dostępu'}`);
+        return;
+      }
+
+      const allItems = Array.isArray(res.data) ? res.data : (res.data?.skills || []);
+      items = allItems.filter((s) => matchSkillQuery(s, searchQuery));
+    }
+  } else {
+    const res = await skillsHub.listSkills({
+      tag: flags.tag,
+      category: flags.category,
+      scope: flags.scope,
+      limit: flags.limit || 200,
+    });
+
+    if (!res.ok) {
+      err(`✗ Błąd pobierania skilli (${res.status}): ${res.data?.error || 'Brak dostępu'}`);
+      return;
+    }
+
+    items = Array.isArray(res.data) ? res.data : (res.data?.skills || []);
   }
 
-  const items = Array.isArray(res.data) ? res.data : (res.data?.skills || []);
   const agents = detectAgents({
     dir: flags.dir,
     agent: flags.agent,
@@ -297,6 +418,9 @@ async function cmdSkillList(flags, out, err) {
       const insp = inspectSkillForAgents(agents, s, lock);
       return {
         ...s,
+        similarity: s.similarity != null ? s.similarity : null,
+        vector_score: s.vector_score != null ? s.vector_score : null,
+        text_score: s.text_score != null ? s.text_score : null,
         overall_status: insp.overallStatus,
         agents: Object.fromEntries(
           Object.entries(insp.agents).map(([id, data]) => [
@@ -328,9 +452,22 @@ async function cmdSkillList(flags, out, err) {
     };
   }
 
-  out(`\n=== Dostępne Skille w DeerSkills Hub (${items.length}) ===\n`);
+  const titleHeader = isSearch
+    ? `=== Wyniki wyszukiwania w DeerSkills Hub dla „${searchQuery}” (${items.length}) ===`
+    : `=== Dostępne Skille w DeerSkills Hub (${items.length}) ===`;
+  out(`\n${titleHeader}\n`);
+
+  if (items.length === 0 && isSearch) {
+    out(`  Nie znaleziono żadnego skilla pasującego do frazy „${searchQuery}”.`);
+    out(`  (Przeszukano: wektory semantyczne, nazwy/slugi, opisy [summary], tagi oraz kategorie).`);
+    out(`\n💡 Wskazówka: Uruchom \x1b[36mdeertools skill list\x1b[0m aby zobaczyć wszystkie dostępne skille.`);
+    out('─'.repeat(78) + '\n');
+    return;
+  }
+
   for (const s of items) {
-    const badge = s.scope === 'global' ? '★ GLOBAL' : `@${s.namespace}`;
+    const namespace = s.namespace || (s.full_slug?.startsWith('@') ? s.full_slug.split('/')[0].slice(1) : '');
+    const badge = s.scope === 'global' ? '★ GLOBAL' : (namespace ? `@${namespace}` : (s.scope === 'team' ? '[Team]' : '[User]'));
     const latestVer = s.latest_version ? `v${s.latest_version}` : 'v1.0.0';
     const insp = inspectSkillForAgents(agents, s, lock);
 
@@ -342,8 +479,12 @@ async function cmdSkillList(flags, out, err) {
     }
 
     const agentBadges = agents.map((a) => insp.agents[a.id].badge).join(' ');
+    const simBadge = (s.similarity != null && isSearch)
+      ? `\x1b[36m[Trafność: ${Math.round(s.similarity * 100)}%]\x1b[0m`
+      : '';
 
-    out(`  • ${s.full_slug.padEnd(36)} ${latestVer.padEnd(10)} ${badge.padEnd(14)} ${insp.overallBadge}`);
+    const fullSlug = s.full_slug || s.slug || '';
+    out(`  • ${fullSlug.padEnd(36)} ${latestVer.padEnd(10)} ${badge.padEnd(14)} ${insp.overallBadge}${simBadge ? ' ' + simBadge : ''}`);
     out(`    Agenci: ${agentBadges}`);
     if (s.summary) out(`    ${s.summary.slice(0, 95)}...`);
     if (s.tags && s.tags.length) out(`    Tagi: ${s.tags.join(', ')}`);
@@ -1239,4 +1380,5 @@ module.exports = {
   updateSkills,
   scanLocalSkills,
   inspectSkillForAgents,
+  matchSkillQuery,
 };

package/src/skills-hub.js

@@ -8,6 +8,8 @@ const { parseFrontmatterName } = require('./openapi');
 const { compareSemver } = require('./updater');
 
 const DEFAULT_API_BASE = 'https://ezspmlsnmxuhtzvwrnoj.supabase.co/functions/v1/skills-api';
+const DEFAULT_SUPABASE_URL = 'https://ezspmlsnmxuhtzvwrnoj.supabase.co';
+const DEFAULT_ANON_KEY = 'sb_publishable_y8iokK-V2X6A1HZb94g_pw_Le0bm3f2';
 const SECRET_PATTERNS = [
   { name: 'DeerTools Live API Key', regex: /deer_[a-z]+_live_[A-Za-z0-9_]{20,}/g },
   { name: 'GitHub Token', regex: /gh[pousr]_[A-Za-z0-9_]{30,}/g },
@@ -87,6 +89,67 @@ async function listSkills(params = {}) {
   return hubRequest(`/skills${qs ? `?${qs}` : ''}`);
 }
 
+function getSupabaseUrl() {
+  return process.env.DEERTOOLS_SUPABASE_URL || DEFAULT_SUPABASE_URL;
+}
+
+function getSupabaseAnonKey() {
+  return process.env.DEERTOOLS_SUPABASE_KEY || DEFAULT_ANON_KEY;
+}
+
+/**
+ * Serwerowe wyszukiwanie wektorowo-hybrydowe (PostgreSQL pgvector + trigram + keyword boost).
+ */
+async function searchSkillsHybrid({ queryText = '', queryEmbedding = null, threshold = 0.05, count = 50 } = {}) {
+  const base = getSupabaseUrl().replace(/\/+$/, '');
+  const url = `${base}/rest/v1/rpc/match_skills_hybrid`;
+  const anonKey = getSupabaseAnonKey();
+  const userKey = getApiKey();
+
+  const body = {
+    query_text: String(queryText || ''),
+    query_embedding: queryEmbedding || null,
+    match_threshold: threshold,
+    match_count: count,
+  };
+  if (userKey) {
+    body.caller_api_key = userKey;
+  }
+
+  const headers = {
+    'Content-Type': 'application/json',
+    'apikey': anonKey,
+    'Authorization': `Bearer ${anonKey}`,
+    'User-Agent': 'deertools-cli',
+  };
+
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+    });
+    let data = null;
+    try {
+      data = await res.json();
+    } catch (_) {
+      data = null;
+    }
+    return {
+      ok: res.ok,
+      status: res.status,
+      data,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      status: 500,
+      data: null,
+      error: err.message,
+    };
+  }
+}
+
 async function getSkill(slug, version = null) {
   const ver = typeof version === 'object' && version !== null ? version.version : version;
   const qs = ver ? `?version=${encodeURIComponent(ver)}` : '';
@@ -472,8 +535,11 @@ async function submitReview(slug) {
 module.exports = {
   getApiBase,
   getApiKey,
+  getSupabaseUrl,
+  getSupabaseAnonKey,
   scanForSecrets,
   listSkills,
+  searchSkillsHybrid,
   getSkill,
   pushSkill,
   bumpVersion,

package/src/supplier/cli-commands.js

@@ -0,0 +1,32 @@
+'use strict';
+const { runSupplierMcpServer } = require('./mcp-server');
+
+function out(msg) { process.stdout.write(msg + '\n'); }
+
+async function cmdSupplier(pos) {
+  const sub = pos[0];
+
+  if (sub === 'mcp') {
+    return runSupplierMcpServer();
+  }
+
+  out(`Użycie: deertools supplier mcp
+
+Zgodnie ze standardem architektonicznym DeerTools CLI:
+- Operacje biznesowe na rabatach, narzutach i dostawcach wykonuje Agent AI wyłącznie przez serwer MCP (deer-supplier).
+- Dostępne narzędzia MCP:
+    * supplier_list_suppliers
+    * supplier_get_discounts
+    * supplier_get_markups
+    * supplier_get_sales_discounts
+    * supplier_evaluate_batch
+    * supplier_list_rules
+    * supplier_list_taxonomy
+    * supplier_list_configurations
+
+Aby zainstalować serwer MCP w Cursor / Antigravity, uruchom:
+  deertools mcp install
+`);
+}
+
+module.exports = { cmdSupplier };

package/src/supplier/mcp-server.js

@@ -0,0 +1,360 @@
+'use strict';
+const readline = require('readline');
+const credentials = require('../credentials');
+const { getProduct } = require('../registry');
+
+const PROTOCOL_VERSION = '2024-11-05';
+const SERVER_INFO = { name: 'deer-supplier-mcp', version: '1.0.0' };
+const SUPPLIER_API_BASE = 'https://hubnxvzxdgocbtmkfdsz.supabase.co/functions/v1/public-api';
+
+function getSupplierKey() {
+  const p = getProduct('supplier');
+  const cred = credentials.getKey(p);
+  if (cred && cred.key) return cred.key;
+  if (process.env.SUPPLIER_API_KEY) return process.env.SUPPLIER_API_KEY;
+  if (process.env.DEERTOOLS_SUPPLIER_KEY) return process.env.DEERTOOLS_SUPPLIER_KEY;
+  return null;
+}
+
+function ensureSupplierAuth() {
+  const key = getSupplierKey();
+  if (!key) {
+    throw new Error('Brak klucza API do Supplier Hub. Zaloguj się poleceniem: deertools login supplier');
+  }
+  return key;
+}
+
+async function callSupplierApi(method, path, { query = {}, body = undefined } = {}) {
+  const apiKey = ensureSupplierAuth();
+  const url = new URL(SUPPLIER_API_BASE + path);
+  for (const [k, v] of Object.entries(query)) {
+    if (v !== undefined && v !== null && v !== '') {
+      url.searchParams.set(k, String(v));
+    }
+  }
+  const headers = {
+    'x-api-key': apiKey,
+    'Accept': 'application/json'
+  };
+  let payload;
+  if (body !== undefined) {
+    headers['Content-Type'] = 'application/json';
+    payload = JSON.stringify(body);
+  }
+  const res = await fetch(url.toString(), { method, headers, body: payload });
+  const text = await res.text();
+  let json = null;
+  try { json = JSON.parse(text); } catch (_) {}
+  if (!res.ok) {
+    throw new Error(`Supplier Hub API (${res.status}): ${(json && json.error) || text}`);
+  }
+  return json !== null ? json : text;
+}
+
+const SUPPLIER_TOOLS = [
+  {
+    name: 'supplier_list_suppliers',
+    description: 'Wyszukuje dostawców dla producenta i lokalizacji (kod pocztowy, miasto lub województwo) w DeerTools Supplier Hub.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        manufacturer: {
+          type: 'string',
+          description: 'Nazwa, external_id lub UUID producenta (np. "Flügger", "LAUFEN", "Roca").'
+        },
+        postal_code: {
+          type: 'string',
+          description: 'Kod pocztowy w formacie XX-XXX (np. "00-001", "30-001").'
+        },
+        city: {
+          type: 'string',
+          description: 'Nazwa miasta/gminy (np. "Warszawa", "Kraków").'
+        },
+        voivodeship: {
+          type: 'string',
+          description: 'Nazwa województwa.'
+        },
+        pick: {
+          type: 'string',
+          enum: ['random', 'first', 'all'],
+          default: 'all',
+          description: 'Sposób zwracania dopasowanych dostawców (domyślnie all).'
+        }
+      },
+      required: ['manufacturer']
+    }
+  },
+  {
+    name: 'supplier_get_discounts',
+    description: 'Dopasowuje aktywne rabaty zakupowe w Supplier Hub dla producenta, kolekcji, kategorii lub produktu.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        manufacturer: { type: 'string', description: 'Nazwa, external_id lub UUID producenta.' },
+        supplier: { type: 'string', description: 'Opcjonalna nazwa lub UUID dostawcy.' },
+        collection: { type: 'string', description: 'Opcjonalna nazwa kolekcji.' },
+        category: { type: 'string', description: 'Opcjonalna nazwa kategorii.' },
+        tag: { type: 'string', description: 'Opcjonalny tag produktu.' },
+        product_id: { type: 'string', description: 'Opcjonalny identyfikator lub SKU produktu.' },
+        best_only: { type: 'boolean', default: false, description: 'Czy zwrócić wyłącznie najwyżej dopasowany rabat.' }
+      },
+      required: ['manufacturer']
+    }
+  },
+  {
+    name: 'supplier_get_markups',
+    description: 'Dopasowuje narzuty cenowe w Supplier Hub dla producenta, kolekcji, kategorii lub produktu.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        manufacturer: { type: 'string', description: 'Nazwa, external_id lub UUID producenta.' },
+        supplier: { type: 'string', description: 'Opcjonalna nazwa lub UUID dostawcy.' },
+        collection: { type: 'string', description: 'Opcjonalna nazwa kolekcji.' },
+        category: { type: 'string', description: 'Opcjonalna nazwa kategorii.' },
+        tag: { type: 'string', description: 'Opcjonalny tag produktu.' },
+        product_id: { type: 'string', description: 'Opcjonalny identyfikator lub SKU produktu.' },
+        best_only: { type: 'boolean', default: false, description: 'Czy zwrócić wyłącznie najlepiej dopasowany narzut.' }
+      },
+      required: ['manufacturer']
+    }
+  },
+  {
+    name: 'supplier_get_sales_discounts',
+    description: 'Dopasowuje aktywne promocje sprzedaży w Supplier Hub dla producenta, kolekcji lub produktu.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        manufacturer: { type: 'string', description: 'Nazwa, external_id lub UUID producenta.' },
+        supplier: { type: 'string', description: 'Opcjonalna nazwa lub UUID dostawcy.' },
+        collection: { type: 'string', description: 'Opcjonalna nazwa kolekcji.' },
+        category: { type: 'string', description: 'Opcjonalna nazwa kategorii.' },
+        tag: { type: 'string', description: 'Opcjonalny tag produktu.' },
+        product_id: { type: 'string', description: 'Opcjonalny identyfikator lub SKU produktu.' },
+        best_only: { type: 'boolean', default: false, description: 'Czy zwrócić wyłącznie najlepiej dopasowaną promocję.' }
+      },
+      required: ['manufacturer']
+    }
+  },
+  {
+    name: 'supplier_evaluate_batch',
+    description: 'Wsadowe dopasowanie rabatów zakupowych, narzutów lub promocji sprzedaży dla maksymalnie 500 produktów jednego producenta.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        type: {
+          type: 'string',
+          enum: ['discounts', 'markups', 'sales-discounts'],
+          default: 'discounts',
+          description: 'Typ wyliczanych reguł: discounts (rabaty zakupowe), markups (narzuty), sales-discounts (promocje).'
+        },
+        manufacturer: { type: 'string', description: 'Nazwa, external_id lub UUID producenta.' },
+        best_only: { type: 'boolean', default: true, description: 'Czy zwracać tylko najlepsze dopasowanie per pozycja.' },
+        items: {
+          type: 'array',
+          description: 'Lista pozycji do przeliczenia (każda z unikalnym kluczem key).',
+          items: {
+            type: 'object',
+            properties: {
+              key: { type: 'string' },
+              product_id: { type: 'string' },
+              collection: { type: 'string' },
+              category: { type: 'string' },
+              tag: { type: 'string' }
+            },
+            required: ['key']
+          }
+        }
+      },
+      required: ['manufacturer', 'items']
+    }
+  },
+  {
+    name: 'supplier_list_rules',
+    description: 'Pobiera listę reguł cenowych (discounts, sales-discounts lub markups) wraz z warunkami.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        type: {
+          type: 'string',
+          enum: ['discounts', 'markups', 'sales-discounts'],
+          default: 'discounts',
+          description: 'Typ reguł cenowych.'
+        },
+        limit: { type: 'number', default: 50, description: 'Limit wyników (domyślnie 50).' },
+        include_conditions: { type: 'boolean', default: true, description: 'Czy dołączyć warunki reguł.' }
+      }
+    }
+  },
+  {
+    name: 'supplier_list_taxonomy',
+    description: 'Wyszukuje pozycje taksonomii w Supplier Hub (collections, categories lub tags).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        type: {
+          type: 'string',
+          enum: ['collections', 'categories', 'tags'],
+          default: 'collections',
+          description: 'Typ taksonomii.'
+        },
+        search: { type: 'string', description: 'Fraza wyszukiwania.' },
+        limit: { type: 'number', default: 50, description: 'Limit wyników.' }
+      }
+    }
+  },
+  {
+    name: 'supplier_list_configurations',
+    description: 'Pobiera konfiguracje powiązań dostawca–producent z Supplier Hub.',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
+  }
+];
+
+async function handleMcpMessage(msg) {
+  if (!msg || typeof msg !== 'object') return null;
+  const { id, method, params } = msg;
+
+  if (method === 'initialize') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo: SERVER_INFO
+      }
+    };
+  }
+
+  if (method === 'notifications/initialized' || method === 'initialized') {
+    return null;
+  }
+
+  if (method === 'ping') {
+    return { jsonrpc: '2.0', id, result: {} };
+  }
+
+  if (method === 'tools/list') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: { tools: SUPPLIER_TOOLS }
+    };
+  }
+
+  if (method === 'tools/call') {
+    const toolName = params?.name;
+    const args = params?.arguments || {};
+
+    try {
+      let data;
+      if (toolName === 'supplier_list_suppliers') {
+        data = await callSupplierApi('GET', '/suppliers', {
+          query: {
+            manufacturer: args.manufacturer,
+            postal_code: args.postal_code,
+            city: args.city,
+            voivodeship: args.voivodeship,
+            pick: args.pick || 'all'
+          }
+        });
+      } else if (toolName === 'supplier_get_discounts') {
+        data = await callSupplierApi('GET', '/discounts', { query: args });
+      } else if (toolName === 'supplier_get_markups') {
+        data = await callSupplierApi('GET', '/markups', { query: args });
+      } else if (toolName === 'supplier_get_sales_discounts') {
+        data = await callSupplierApi('GET', '/sales-discounts', { query: args });
+      } else if (toolName === 'supplier_evaluate_batch') {
+        const type = args.type || 'discounts';
+        data = await callSupplierApi('POST', `/${type}/evaluate`, {
+          body: {
+            manufacturer: args.manufacturer,
+            best_only: args.best_only !== false,
+            items: args.items
+          }
+        });
+      } else if (toolName === 'supplier_list_rules') {
+        const type = args.type || 'discounts';
+        data = await callSupplierApi('GET', `/rules/${type}`, {
+          query: {
+            limit: args.limit || 50,
+            include_conditions: args.include_conditions !== false
+          }
+        });
+      } else if (toolName === 'supplier_list_taxonomy') {
+        const type = args.type || 'collections';
+        data = await callSupplierApi('GET', `/taxonomy/${type}`, {
+          query: { search: args.search, limit: args.limit || 50 }
+        });
+      } else if (toolName === 'supplier_list_configurations') {
+        data = await callSupplierApi('GET', '/supplier-configurations');
+      } else {
+        return {
+          jsonrpc: '2.0',
+          id,
+          error: { code: -32601, message: `Nieznane narzędzie: ${toolName}` }
+        };
+      }
+
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+          content: [{ type: 'text', text: JSON.stringify(data, null, 2) }]
+        }
+      };
+    } catch (e) {
+      return {
+        jsonrpc: '2.0',
+        id,
+        error: { code: -32000, message: e.message }
+      };
+    }
+  }
+
+  return {
+    jsonrpc: '2.0',
+    id,
+    error: { code: -32601, message: `Nieobsługiwana metoda: ${method}` }
+  };
+}
+
+function runSupplierMcpServer() {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false
+    });
+
+    rl.on('line', async (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      try {
+        const msg = JSON.parse(trimmed);
+        const resp = await handleMcpMessage(msg);
+        if (resp) {
+          process.stdout.write(JSON.stringify(resp) + '\n');
+        }
+      } catch (e) {
+        process.stdout.write(JSON.stringify({
+          jsonrpc: '2.0',
+          id: null,
+          error: { code: -32700, message: `Parse error: ${e.message}` }
+        }) + '\n');
+      }
+    });
+
+    rl.on('close', () => resolve());
+    process.on('SIGINT', () => { rl.close(); resolve(); });
+    process.on('SIGTERM', () => { rl.close(); resolve(); });
+  });
+}
+
+module.exports = {
+  SUPPLIER_TOOLS,
+  handleMcpMessage,
+  runSupplierMcpServer
+};