@deerdesign/deertools 1.0.3 → 1.2.0

package/src/mcp-stdio.js

@@ -0,0 +1,197 @@
+'use strict';
+const readline = require('readline');
+const credentials = require('./credentials');
+const { ALL_PRODUCTS } = require('./registry');
+const { apiRequest } = require('./http');
+
+const PROTOCOL_VERSION = '2024-11-05';
+const SERVER_INFO = { name: 'deertools-stdio-bridge', version: '1.0.5' };
+
+async function cmdMcpServe(pos, flags) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+
+  function send(msg) {
+    process.stdout.write(JSON.stringify(msg) + '\n');
+  }
+
+  rl.on('line', async (line) => {
+    if (!line.trim()) return;
+    let req;
+    try { req = JSON.parse(line); } catch (e) {
+      send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } });
+      return;
+    }
+
+    const { id, method, params } = req;
+
+    if (method === 'initialize') {
+      send({
+        jsonrpc: '2.0',
+        id,
+        result: {
+          protocolVersion: PROTOCOL_VERSION,
+          serverInfo: SERVER_INFO,
+          capabilities: { tools: {} },
+        },
+      });
+      return;
+    }
+
+    if (method === 'notifications/initialized') {
+      return;
+    }
+
+    if (method === 'tools/list') {
+      const tools = [
+        {
+          name: 'estimate_calculate',
+          description: 'Szybkie wyliczenie kosztu wykończenia mieszkania z podanego metrażu w pakietach Smart Life, Modern Life, High Life.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              area_m2: { type: 'number', description: 'Metraż mieszkania w m²' },
+              package: { type: 'string', enum: ['smart_life', 'modern_life', 'high_life'], description: 'Pakiet wykończeniowy' },
+            },
+            required: ['area_m2'],
+          },
+        },
+        {
+          name: 'catalog_search_products',
+          description: 'Wyszukiwanie produktów w Katalogu Connect Deer Design po frazie, kategorii i pakiecie.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              query: { type: 'string', description: 'Szukana fraza (nazwa, SKU, producent)' },
+              package: { type: 'string', enum: ['smart-life', 'modern-life', 'high-life'] },
+              limit: { type: 'number', default: 10 },
+            },
+            required: ['query'],
+          },
+        },
+        {
+          name: 'deliveries_list',
+          description: 'Pobieranie listy dostaw z systemu logistycznego Delivery Hub.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              status: { type: 'string', description: 'Filtruj po statusie dostawy' },
+              limit: { type: 'number', default: 20 },
+            },
+          },
+        },
+        {
+          name: 'supplier_calculate_price',
+          description: 'Kalkulator łańcucha marżowego: cena katalogowa -> rabat zakupu -> narzut sprzedaży -> marża zysku.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              catalog_price_net: { type: 'number', description: 'Cena katalogowa netto' },
+              discount_pct: { type: 'number', description: 'Rabat zakupu w % (np. 35)' },
+              markup_pct: { type: 'number', description: 'Narzut sprzedaży w % (np. 20)' },
+            },
+            required: ['catalog_price_net'],
+          },
+        },
+      ];
+
+      send({ jsonrpc: '2.0', id, result: { tools } });
+      return;
+    }
+
+    if (method === 'tools/call') {
+      const toolName = params?.name;
+      const args = params?.arguments || {};
+
+      try {
+        if (toolName === 'estimate_calculate') {
+          const area = Number(args.area_m2);
+          const pkg = args.package || 'modern_life';
+          const pkgs = {
+            smart_life: { name: 'Smart Life', rate: 1290, flat: 58050 },
+            modern_life: { name: 'Modern Life', rate: 1640, flat: 73800 },
+            high_life: { name: 'High Life', rate: 1990, flat: 89550 },
+          };
+          const p = pkgs[pkg] || pkgs.modern_life;
+          const isFlat = area < 45;
+          const gross = isFlat ? p.flat : Math.round(area * p.rate);
+          const net = Math.round(gross / 1.08);
+
+          send({
+            jsonrpc: '2.0',
+            id,
+            result: {
+              content: [{
+                type: 'text',
+                text: JSON.stringify({
+                  package: p.name,
+                  area_m2: area,
+                  total_gross_pln: gross,
+                  total_net_pln: net,
+                  is_flat_rate: isFlat,
+                  currency: 'PLN',
+                }, null, 2),
+              }],
+            },
+          });
+          return;
+        }
+
+        if (toolName === 'catalog_search_products') {
+          const p = getProduct('katalog');
+          const res = await apiRequest(p, { method: 'GET', path: '/products', query: { search: args.query, program: args.package, limit: args.limit || 10 } });
+          send({
+            jsonrpc: '2.0',
+            id,
+            result: { content: [{ type: 'text', text: JSON.stringify(res.json?.data || res.json || [], null, 2) }] },
+          });
+          return;
+        }
+
+        if (toolName === 'deliveries_list') {
+          const p = getProduct('dostawy');
+          const res = await apiRequest(p, { method: 'GET', path: '/deliveries-api/deliveries', query: { status: args.status, limit: args.limit || 20 } });
+          send({
+            jsonrpc: '2.0',
+            id,
+            result: { content: [{ type: 'text', text: JSON.stringify(res.json || [], null, 2) }] },
+          });
+          return;
+        }
+
+        if (toolName === 'supplier_calculate_price') {
+          const cat = Number(args.catalog_price_net);
+          const disc = Number(args.discount_pct || 30);
+          const mark = Number(args.markup_pct || 20);
+          const buy = cat * (1 - disc / 100);
+          const sell = buy * (1 + mark / 100);
+          send({
+            jsonrpc: '2.0',
+            id,
+            result: {
+              content: [{
+                type: 'text',
+                text: JSON.stringify({
+                  catalog_price_net: cat,
+                  buy_price_net: Math.round(buy * 100) / 100,
+                  sell_price_net: Math.round(sell * 100) / 100,
+                  margin_net: Math.round((sell - buy) * 100) / 100,
+                  margin_pct: Math.round(((sell - buy) / sell) * 1000) / 10,
+                }, null, 2),
+              }],
+            },
+          });
+          return;
+        }
+
+        send({ jsonrpc: '2.0', id, error: { code: -32601, message: `Tool not found: ${toolName}` } });
+      } catch (e) {
+        send({ jsonrpc: '2.0', id, error: { code: -32000, message: e.message } });
+      }
+      return;
+    }
+
+    send({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } });
+  });
+}
+
+module.exports = { cmdMcpServe };

package/src/profiles.js

@@ -0,0 +1,78 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { c } = require('./formatters');
+
+function getConfigDir() {
+  return process.env.DEERTOOLS_HOME || path.join(os.homedir(), '.deertools');
+}
+
+function getConfigFile() {
+  return path.join(getConfigDir(), 'config.json');
+}
+
+function readConfig() {
+  const f = getConfigFile();
+  if (!fs.existsSync(f)) return { activeProfile: 'default', profiles: { default: {} } };
+  try {
+    return JSON.parse(fs.readFileSync(f, 'utf8'));
+  } catch (_) {
+    return { activeProfile: 'default', profiles: { default: {} } };
+  }
+}
+
+function writeConfig(cfg) {
+  const dir = getConfigDir();
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(getConfigFile(), JSON.stringify(cfg, null, 2), { mode: 0o600 });
+}
+
+function getActiveProfile() {
+  if (process.env.DEERTOOLS_PROFILE) return process.env.DEERTOOLS_PROFILE;
+  return readConfig().activeProfile || 'default';
+}
+
+async function cmdProfile(pos, flags) {
+  const action = pos[0] || 'list';
+  const cfg = readConfig();
+
+  if (action === 'list') {
+    const active = getActiveProfile();
+    process.stdout.write(`\n${c.bold}Profile poświadczeń DeerTools:${c.reset}\n`);
+    const profiles = Object.keys(cfg.profiles || { default: {} });
+    if (!profiles.includes('default')) profiles.unshift('default');
+    for (const p of profiles) {
+      const isCur = p === active;
+      const marker = isCur ? `${c.green}* ${c.bold}` : '  ';
+      process.stdout.write(`${marker}${p}${isCur ? ' (aktywny)' : ''}${c.reset}\n`);
+    }
+    process.stdout.write(`\nAby przełączyć profil: deertools profile use <nazwa>\n`);
+    return;
+  }
+
+  if (action === 'use') {
+    const target = pos[1];
+    if (!target) {
+      process.stderr.write('Błąd: Podaj nazwę profilu: deertools profile use <nazwa>\n');
+      process.exitCode = 2;
+      return;
+    }
+    cfg.activeProfile = target;
+    if (!cfg.profiles) cfg.profiles = {};
+    if (!cfg.profiles[target]) cfg.profiles[target] = {};
+    writeConfig(cfg);
+    process.stdout.write(`✓ Przełączono na profil: ${c.bold}${target}${c.reset}\n`);
+    return;
+  }
+
+  if (action === 'current') {
+    process.stdout.write(`${getActiveProfile()}\n`);
+    return;
+  }
+
+  process.stderr.write('Użycie: deertools profile [list|use <nazwa>|current]\n');
+  process.exitCode = 2;
+}
+
+module.exports = { cmdProfile, getActiveProfile, readConfig, writeConfig };

package/src/registry.js

@@ -18,6 +18,7 @@ const PRODUCTS = {
     tokenUrl: 'https://vlemuxlubrowuuxpgllk.supabase.co/functions/v1/oauth-token',
     keyPrefix: 'deer_kosztorys_live_',
     fallbackApiBase: 'https://vlemuxlubrowuuxpgllk.supabase.co/functions/v1',
+    mcpEndpoint: 'https://vlemuxlubrowuuxpgllk.supabase.co/functions/v1/estimate-mcp',
     aliases: ['kosztorys', 'costs', 'cost'],
   },
   catalog: {
@@ -28,6 +29,7 @@ const PRODUCTS = {
     tokenUrl: 'https://ftzaobeixglnssemugjf.supabase.co/functions/v1/oauth-token',
     keyPrefix: 'deer_catalog_live_',
     fallbackApiBase: 'https://ftzaobeixglnssemugjf.supabase.co/functions/v1/api-gateway',
+    mcpEndpoint: 'https://ftzaobeixglnssemugjf.supabase.co/functions/v1/catalog-mcp',
     aliases: ['katalog'],
   },
   deliveries: {
@@ -38,6 +40,7 @@ const PRODUCTS = {
     tokenUrl: 'https://ddyfbvogkumvscckotvb.supabase.co/functions/v1/oauth-token',
     keyPrefix: 'deer_dostawy_live_',
     fallbackApiBase: 'https://ddyfbvogkumvscckotvb.supabase.co/functions/v1',
+    mcpEndpoint: 'https://ddyfbvogkumvscckotvb.supabase.co/functions/v1/mcp-server',
     aliases: ['dostawy', 'shipping', 'delivery', 'ship'],
   },
   supplier: {
@@ -48,6 +51,7 @@ const PRODUCTS = {
     tokenUrl: 'https://hubnxvzxdgocbtmkfdsz.supabase.co/functions/v1/oauth-token',
     keyPrefix: 'deer_supplier_live_',
     fallbackApiBase: 'https://hubnxvzxdgocbtmkfdsz.supabase.co/functions/v1/public-api',
+    mcpEndpoint: 'https://hubnxvzxdgocbtmkfdsz.supabase.co/functions/v1/mcp',
     aliases: [],
   },
   rendermind: {
@@ -58,8 +62,20 @@ const PRODUCTS = {
     tokenUrl: 'https://lkljsuptgyktkwojnwbu.supabase.co/functions/v1/oauth-token',
     keyPrefix: 'deer_rendermind_live_',
     fallbackApiBase: 'https://lkljsuptgyktkwojnwbu.supabase.co/functions/v1/rendermind-api',
+    mcpEndpoint: 'https://lkljsuptgyktkwojnwbu.supabase.co/functions/v1/mcp',
     aliases: [],
   },
+  skills: {
+    name: 'DeerSkills',
+    localName: 'DeerSkills Hub',
+    site: 'https://skills.deergroup.pl',
+    authorizeUrl: 'https://skills.deergroup.pl/oauth/authorize',
+    tokenUrl: 'https://ezspmlsnmxuhtzvwrnoj.supabase.co/functions/v1/oauth-token',
+    keyPrefix: 'deer_skills_live_',
+    fallbackApiBase: 'https://ezspmlsnmxuhtzvwrnoj.supabase.co/functions/v1/skills-api',
+    mcpEndpoint: 'https://ezspmlsnmxuhtzvwrnoj.supabase.co/functions/v1/skills-mcp',
+    aliases: ['hub', 'skill', 'umiejetnosci'],
+  },
 };
 
 const ALIASES = {
@@ -71,6 +87,9 @@ const ALIASES = {
   shipping: 'deliveries',
   delivery: 'deliveries',
   ship: 'deliveries',
+  hub: 'skills',
+  skill: 'skills',
+  umiejetnosci: 'skills',
 };
 
 const ALL_IDS = Object.keys(PRODUCTS);
@@ -91,4 +110,6 @@ function resolveProducts(arg) {
   return String(arg).split(',').map((s) => getProduct(s.trim()));
 }
 
-module.exports = { PRODUCTS, ALIASES, ALL_IDS, getProduct, resolveProducts };
+const ALL_PRODUCTS = ALL_IDS.map(getProduct);
+
+module.exports = { PRODUCTS, ALIASES, ALL_IDS, ALL_PRODUCTS, getProduct, resolveProducts };

package/src/skill-commands.js

@@ -0,0 +1,223 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const { detectAgents, installSkillContent } = require('./agent-detector');
+const skillsHub = require('./skills-hub');
+const { parseFrontmatterName } = require('./openapi');
+const { resolveProducts } = require('./registry');
+const { fetchText } = require('./http');
+
+const LOCK_FILE = '.deertools-lock.json';
+
+function readLock(cwd = process.cwd()) {
+  const p = path.join(cwd, LOCK_FILE);
+  if (fs.existsSync(p)) {
+    try {
+      return JSON.parse(fs.readFileSync(p, 'utf8'));
+    } catch (_) {}
+  }
+  return { version: 1, skills: {} };
+}
+
+function writeLock(data, cwd = process.cwd()) {
+  const p = path.join(cwd, LOCK_FILE);
+  fs.writeFileSync(p, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+async function cmdSkillList(flags, out, err) {
+  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 || 50,
+  });
+
+  if (!res.ok) {
+    err(`✗ Błąd pobierania skilli (${res.status}): ${res.data?.error || 'Brak dostępu'}`);
+    return;
+  }
+
+  const items = res.data?.skills || [];
+  if (flags.json) {
+    out(JSON.stringify(items, null, 2));
+    return;
+  }
+
+  out(`\n=== Dostępne Skille w DeerSkills Hub (${items.length}) ===\n`);
+  for (const s of items) {
+    const badge = s.scope === 'global' ? '★ GLOBAL' : `@${s.namespace}`;
+    const ver = s.latest_version ? `v${s.latest_version}` : 'v1.0.0';
+    out(`  • ${s.full_slug.padEnd(35)} [${ver}] [${badge}]`);
+    if (s.summary) out(`    ${s.summary.slice(0, 90)}...`);
+    if (s.tags && s.tags.length) out(`    Tagi: ${s.tags.join(', ')}`);
+    out('');
+  }
+}
+
+async function cmdSkillSearch(query, flags, out, err) {
+  return cmdSkillList({ ...flags, query }, out, err);
+}
+
+async function cmdSkillInstall(target, flags, out, err) {
+  let [slug, requestedVersion] = String(target || '').split('@');
+  slug = slug.trim();
+
+  // Jeśli brak argumentu lub "all" lub nazwa produktu Deer, zachowaj kompatybilność wsteczną
+  if (!slug || slug === 'all' || ['estimate', 'catalog', 'deliveries', 'supplier', 'rendermind'].includes(slug)) {
+    const products = resolveProducts(slug || 'all');
+    const agents = detectAgents({ dir: flags.dir, agent: flags.agent });
+    let installed = 0;
+
+    for (const product of products) {
+      const r = await fetchText(`${product.site}/skill/SKILL.md`);
+      if (!r.ok) continue;
+      const skillName = parseFrontmatterName(r.text) || `deer-${product.id}`;
+      for (const agent of agents) {
+        try {
+          const dest = installSkillContent(agent, skillName, r.text);
+          out(`✓ [${agent.id}] ${product.name}: ${dest}`);
+          installed += 1;
+        } catch (e) {
+          err(`✗ [${agent.id}] ${product.name}: ${e.message}`);
+        }
+      }
+    }
+    if (!installed) throw new Error('Nie zainstalowano żadnego skilla produktowego.');
+    return;
+  }
+
+  // Instalacja konkretnego skilla z DeerSkills Hub
+  out(`Pobieram skill „${slug}”${requestedVersion ? ` w wersji ${requestedVersion}` : ''} z DeerSkills Hub...`);
+  const res = await skillsHub.getSkill(slug, requestedVersion);
+
+  if (!res.ok || !res.data?.skill) {
+    throw new Error(`Nie znaleziono skilla „${slug}” w DeerSkills Hub (${res.status}): ${res.data?.error || 'Błąd'}`);
+  }
+
+  const skill = res.data.skill;
+  const versionData = res.data.version;
+  const agents = detectAgents({ dir: flags.dir, agent: flags.agent });
+
+  if (agents.length === 0) {
+    throw new Error('Nie wykryto żadnego środowiska agenta AI w bieżącym projekcie.');
+  }
+
+  let count = 0;
+  for (const agent of agents) {
+    try {
+      const dest = installSkillContent(agent, skill.slug, versionData.skill_md_content);
+      out(`✓ [${agent.id}] Zainstalowano ${skill.full_slug} (${versionData.version}) → ${dest}`);
+      count += 1;
+
+      // Jeśli są dodatkowe pliki w manifeście, zapisz je obok SKILL.md
+      if (versionData.files_manifest && Array.isArray(versionData.files_manifest)) {
+        const baseDir = path.dirname(dest);
+        for (const file of versionData.files_manifest) {
+          const targetFile = path.join(baseDir, file.path);
+          fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+          fs.writeFileSync(targetFile, file.content, 'utf8');
+        }
+      }
+    } catch (e) {
+      err(`✗ [${agent.id}] ${skill.slug}: ${e.message}`);
+    }
+  }
+
+  // Zapis do .deertools-lock.json
+  const lock = readLock();
+  lock.skills[skill.slug] = {
+    fullSlug: skill.full_slug,
+    version: versionData.version,
+    installedAt: new Date().toISOString(),
+    sha256: versionData.sha256_checksum,
+  };
+  writeLock(lock);
+  out(`✓ Zaktualizowano ${LOCK_FILE} (wersja ${versionData.version}).`);
+}
+
+async function cmdSkillPush(dir, flags, out, err) {
+  const targetDir = dir || process.cwd();
+  out(`Analizuję folder skilla: ${targetDir}...`);
+
+  const res = await skillsHub.pushSkill(targetDir, {
+    version: flags.version || '1.0.0',
+    changelog: flags.changelog || 'Aktualizacja przez DeerTools CLI',
+    visibility: flags.private ? 'private' : 'shared',
+  });
+
+  if (!res.ok) {
+    throw new Error(`Nie udało się opublikować skilla (${res.status}): ${res.data?.error || 'Błąd serwera'}`);
+  }
+
+  out(`✓ Pomyślnie opublikowano skill w DeerSkills Hub:`);
+  out(`  • Pełny identyfikator: ${res.data.skill.full_slug}`);
+  out(`  • Wersja: ${res.data.version.version}`);
+  out(`  • Widoczność: ${res.data.skill.visibility}`);
+  out(`  • Komenda do instalacji przez innych:`);
+  out(`      deertools skill install ${res.data.skill.full_slug}`);
+}
+
+async function cmdSkillUpdate(flags, out, err) {
+  const lock = readLock();
+  const installedSkills = Object.keys(lock.skills || {});
+
+  if (installedSkills.length === 0) {
+    out('Brak zainstalowanych skilli w pliku .deertools-lock.json.');
+    return;
+  }
+
+  out(`Sprawdzam aktualizacje dla ${installedSkills.length} skilli...`);
+  let updatedCount = 0;
+
+  for (const slug of installedSkills) {
+    const current = lock.skills[slug];
+    try {
+      const res = await skillsHub.getSkill(slug);
+      if (res.ok && res.data?.version) {
+        const latestVer = res.data.version.version;
+        if (latestVer !== current.version) {
+          out(`Aktualizacja ${slug}: ${current.version} → ${latestVer}...`);
+          await cmdSkillInstall(`${slug}@${latestVer}`, flags, out, err);
+          updatedCount += 1;
+        } else {
+          out(`  • ${slug} (${current.version}) — aktualny.`);
+        }
+      }
+    } catch (e) {
+      err(`✗ Błąd sprawdzania ${slug}: ${e.message}`);
+    }
+  }
+
+  if (updatedCount > 0) {
+    out(`\n✓ Zaktualizowano pomyślnie ${updatedCount} skilli.`);
+  } else {
+    out('\nWszystkie zainstalowane skille są w najnowszych wersjach.');
+  }
+}
+
+async function cmdSkillPromote(slug, flags, out, err) {
+  if (!slug) throw new Error('Podaj slug skilla do nominacji, np. deertools skill promote moj-skill');
+  const proposed = flags.to || slug.replace(/^@[^/]+\//, '');
+  const justification = flags.reason || 'Dopracowany skill rekomendowany do oficjalnego katalogu Deer Design.';
+
+  out(`Wysyłam wniosek o nominację skilla „${slug}” do katalogu globalnego jako „deer-${proposed}”...`);
+  const res = await skillsHub.submitPromotion(slug, `deer-${proposed}`, justification);
+
+  if (!res.ok) {
+    throw new Error(`Błąd zgłaszania nominacji (${res.status}): ${res.data?.error || 'Błąd'}`);
+  }
+
+  out('✓ Wniosek o nominację został pomyślnie przesłany do administratorów.');
+  out('  Możesz śledzić status w panelu DeerSkills: https://skills.deergroup.pl/settings');
+}
+
+module.exports = {
+  cmdSkillList,
+  cmdSkillSearch,
+  cmdSkillInstall,
+  cmdSkillPush,
+  cmdSkillUpdate,
+  cmdSkillPromote,
+};