@deerdesign/deertools 1.2.23 → 1.2.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deerdesign/deertools",
-  "version": "1.2.23",
+  "version": "1.2.25",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"

package/src/commands.js

@@ -7,6 +7,7 @@ const { getProduct, resolveProducts, ALL_IDS } = require('./registry');
 const { login, normalizeScope } = require('./login');
 const { discover, fetchText, apiRequest, explain } = require('./http');
 const { listOperations, parseFrontmatterName } = require('./openapi');
+const { calculateEstimate, getEstimateMargins } = require('./estimate-client');
 
 const out = (s = '') => process.stdout.write(`${s}\n`);
 const err = (s = '') => process.stderr.write(`${s}\n`);
@@ -214,75 +215,120 @@ async function cmdApi(pos, flags) {
   out(res.json ? JSON.stringify(res.json, null, flags.raw ? 0 : 2) : res.text);
 }
 
-async function cmdEstimate(pos, flags) {
+async function cmdEstimate(pos, flags, options = {}) {
   const sub = pos[0];
+  const write = options.out || out;
 
   if (sub === 'calculate' || sub === 'calc') {
     const area = Number(pos[1] || flags.area);
-    if (!area || isNaN(area)) fail('Użycie: deertools estimate calculate <metraż_m2> [smart_life|modern_life|high_life]', 2);
-    const pkgs = {
-      smart_life: { name: 'Smart Life', rate: 1290, flat: 58050, marginPct: 33.1 },
-      modern_life: { name: 'Modern Life', rate: 1640, flat: 73800, marginPct: 31.2 },
-      high_life: { name: 'High Life', rate: 1990, flat: 89550, marginPct: 22.7 },
-    };
-    const isFlat = area < 45;
+    if (!area || isNaN(area)) fail('Użycie: deertools estimate calculate <metraż_m2> [smart_life|modern_life|high_life] [--wet=<liczba>] [--doors=<liczba>] [--basis=avg|max]', 2);
+
     const requested = pos[2] || flags.package;
-    const selected = requested ? [pkgs[requested] || pkgs.modern_life] : Object.values(pkgs);
-
-    const results = selected.map(p => {
-      const gross = isFlat ? p.flat : Math.round(area * p.rate);
-      const net = Math.round(gross / 1.08);
-      const vat = gross - net;
-      const profitNet = Math.round(net * (p.marginPct / 100));
-      return {
-        package: p.name,
-        area_m2: area,
-        price_per_m2_gross: p.rate,
-        total_gross_pln: gross,
-        total_net_pln: net,
-        vat_pln: vat,
-        is_flat_rate: isFlat,
-        ref_margin_pct: p.marginPct,
-        est_profit_net_pln: profitNet,
-      };
-    });
-
-    if (flags.json) { out(JSON.stringify(results.length === 1 ? results[0] : results, null, 2)); return; }
-
-    out(`\nKalkulacja wykończenia dla metrażu ${area} m²${isFlat ? ' (stawka ryczałtowa < 45 m²)' : ''}:`);
+    const wetInput = flags.wet !== undefined ? Number(flags.wet) : (flags.wetZones !== undefined ? Number(flags.wetZones) : undefined);
+    const doorsInput = flags.doors !== undefined ? Number(flags.doors) : undefined;
+
+    const data = await calculateEstimate({
+      area_m2: area,
+      package: requested || undefined,
+      wet_zones: wetInput,
+      doors: doorsInput,
+    }, options);
+
+    const estimates = (data && data.estimates) ? data.estimates : [];
+    if (!estimates.length) {
+      fail('Nie otrzymano wyników kalkulacji z serwera Kosztorysu.', 4);
+    }
+
+    const results = estimates.map(e => ({
+      package: e.package,
+      package_key: e.slug,
+      slug: e.slug,
+      area_m2: e.area_m2,
+      price_per_m2_gross: e.price_per_m2_gross,
+      is_flat_rate: !!e.is_lump_sum,
+      is_lump_sum: !!e.is_lump_sum,
+      lump_sum_max_area_m2: e.lump_sum_max_area_m2,
+      base_gross_pln: e.base_gross,
+      base_net_pln: Math.round((e.base_gross / 1.08) * 100) / 100,
+      standard_wet_zones: e.standard_wet_zones,
+      wet_zones: e.wet_zones,
+      extra_wet_zones: Math.max(0, (e.wet_zones || 0) - (e.standard_wet_zones || 0)),
+      wet_surcharge_gross_pln: e.wet_zone_surcharge_gross,
+      wet_surcharge_net_pln: Math.round(((e.wet_zone_surcharge_gross || 0) / 1.08) * 100) / 100,
+      standard_doors: e.standard_doors,
+      doors: (e.standard_doors || 0) + (e.complexity_levels || 0),
+      complexity_levels: e.complexity_levels,
+      complexity_surcharge_label: e.complexity_surcharge_label || 'Dopłata z tytułu złożoności projektu',
+      complexity_surcharge_gross_pln: e.complexity_surcharge_gross,
+      complexity_surcharge_net_pln: Math.round(((e.complexity_surcharge_gross || 0) / 1.08) * 100) / 100,
+      total_gross_pln: e.total_gross,
+      total_net_pln: e.total_net,
+      vat_pln: e.vat_pln,
+      currency: e.currency || 'PLN',
+      max_discount_pct: e.max_discount_pct,
+      discount_locked: e.discount_locked,
+      source: 'Kosztorys Backend API (estimate-mcp)',
+    }));
+
+    if (flags.json) {
+      write(JSON.stringify(results.length === 1 ? results[0] : results, null, 2));
+      return;
+    }
+
+    const isFlat = results.some(r => r.is_flat_rate);
+    write(`\nKalkulacja wykończenia dla metrażu ${area} m² (źródło: Kosztorys API${isFlat ? ', ryczałt do 40 m²' : ''}):`);
     const fmt = (n) => new Intl.NumberFormat('pl-PL', { maximumFractionDigits: 0 }).format(Math.round(n));
     for (const r of results) {
-      out(`  ▶ ${r.package.padEnd(14)} ${fmt(r.total_gross_pln)} zł brutto (${fmt(r.total_net_pln)} zł netto + ${fmt(r.vat_pln)} zł VAT)`);
+      write(`  ▶ ${r.package.padEnd(14)} ${fmt(r.total_gross_pln)} zł brutto (${fmt(r.total_net_pln)} zł netto + ${fmt(r.vat_pln)} zł VAT)`);
+      if (r.extra_wet_zones > 0 || r.complexity_levels > 0) {
+        write(`     - Podstawa: ${fmt(r.base_gross_pln)} zł brutto`);
+        if (r.extra_wet_zones > 0) write(`     - Dodatkowe strefy mokre (+${r.extra_wet_zones}): +${fmt(r.wet_surcharge_gross_pln)} zł brutto`);
+        if (r.complexity_levels > 0) write(`     - ${r.complexity_surcharge_label} (+${r.complexity_levels} drzwi): +${fmt(r.complexity_surcharge_gross_pln)} zł brutto`);
+      }
     }
     return;
   }
 
   if (sub === 'margins') {
     const area = Number(pos[1] || flags.area || 50);
-    const pkgs = [
-      { name: 'Smart Life', rate: 1290, margin: 33.1 },
-      { name: 'Modern Life', rate: 1640, margin: 31.2 },
-      { name: 'High Life', rate: 1990, margin: 22.7 },
-    ];
-    const isFlat = area < 45;
-    const rows = pkgs.map(p => {
-      const gross = isFlat ? (p.rate * 45) : (area * p.rate);
-      const net = gross / 1.08;
-      const profit = net * (p.margin / 100);
-      const cost = net - profit;
-      return {
-        package: p.name,
-        gross: Math.round(gross),
-        net: Math.round(net),
-        cost: Math.round(cost),
-        profit: Math.round(profit),
-        margin: p.margin,
-      };
-    });
-    if (flags.json) { out(JSON.stringify(rows, null, 2)); return; }
-    out(`\nAnaliza marż referencyjnych Deer Design dla ${area} m²:`);
+
+    const data = await getEstimateMargins({
+      area_m2: area,
+    }, options);
+
+    const estimates = (data && data.estimates) ? data.estimates : [];
+    if (!estimates.length) {
+      fail('Nie otrzymano reguł marżowych z serwera Kosztorysu.', 4);
+    }
+
+    const rows = estimates.map(e => ({
+      package: e.package,
+      slug: e.slug,
+      area_m2: e.area_m2,
+      base_gross_pln: e.base_gross,
+      base_net_pln: e.total_net,
+      is_flat_rate: !!e.is_lump_sum,
+      std_wet_zones: e.standard_wet_zones,
+      std_doors: e.standard_doors,
+      wet_surcharge_gross: e.wet_zone_surcharge_gross,
+      complexity_surcharge_label: e.complexity_surcharge_label || 'Dopłata z tytułu złożoności projektu',
+      complexity_surcharge_gross: e.complexity_surcharge_gross,
+      margin_rule_simplified: e.margin_rule_simplified,
+      margin_rule_quick: e.margin_rule_quick,
+      formula: e.formula,
+      note: e.note,
+      source: 'Kosztorys Backend API (estimate-mcp)',
+    }));
+
+    if (flags.json) { write(JSON.stringify(rows, null, 2)); return; }
+    write(`\nZasady wyliczania marży Deer Design (Nowy standard 2026 z Kosztorysu dla ${area} m²):`);
+    write(`  • Kosztorys Uproszczony: ${rows[0]?.margin_rule_simplified}`);
+    write(`  • Kosztorys Szybki: ${rows[0]?.margin_rule_quick}`);
+    write(`  • Formuła marży: ${rows[0]?.formula}`);
+    write(`  • Uwaga: ${rows[0]?.note}\n`);
     for (const r of rows) {
-      out(`  • ${r.package.padEnd(14)} Przychód netto: ${r.net} zł · Koszt: ${r.cost} zł · Zysk: ${r.profit} zł (${r.margin}%)`);
+      write(`  ▶ ${r.package.padEnd(14)} Podstawa: ${r.base_gross_pln} zł brutto (${r.base_net_pln} zł netto) | Std: ${r.std_wet_zones} strefa mokra, ${r.std_doors} drzwi`);
+      write(`     Reguła marży: ${r.margin_rule_simplified}`);
     }
     return;
   }

package/src/estimate-client.js

@@ -0,0 +1,110 @@
+'use strict';
+const credentials = require('./credentials');
+const { getProduct } = require('./registry');
+
+/**
+ * Klient API / MCP dla Kosztorysu Deer Design.
+ * Wszystkie kalkulacje (stawki, progi ryczałtowe do 40 m², dopłaty za strefy mokre,
+ * dopłaty ze względu na złożoność projektu oraz reguły marżowe) są wykonywane
+ * wyłącznie po stronie serwera Kosztorysu (Supabase Edge Function: estimate-mcp).
+ * CLI nie zawiera lokalnie zakodowanych tabel cenowych ani algorytmów marży.
+ */
+
+async function callEstimateMcp(toolName, args = {}, options = {}) {
+  const product = getProduct('estimate');
+  const found = credentials.getKey(product);
+  const apiKey = options.apiKey || (found && found.key);
+
+  if (!apiKey && !options.allowAnonymous) {
+    const err = new Error(
+      `Nie jesteś zalogowany do Kosztorysu. Kalkulacja wymaga autoryzacji z serwera DeerTools.\nUruchom: deertools login estimate`
+    );
+    err.exitCode = 3;
+    throw err;
+  }
+
+  const endpoint = options.endpoint || product.mcpEndpoint || `${product.fallbackApiBase}/estimate-mcp`;
+  const fetchFn = options.fetchImpl || globalThis.fetch;
+
+  const payload = {
+    jsonrpc: '2.0',
+    id: Date.now(),
+    method: 'tools/call',
+    params: {
+      name: toolName,
+      arguments: args,
+    },
+  };
+
+  const headers = {
+    'Content-Type': 'application/json',
+    Accept: 'application/json',
+  };
+  if (apiKey) {
+    headers['x-api-key'] = apiKey;
+  }
+
+  let res;
+  try {
+    res = await fetchFn(endpoint, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(payload),
+    });
+  } catch (netErr) {
+    const err = new Error(`Błąd połączenia z serwerem Kosztorysu (${endpoint}): ${netErr.message}`);
+    err.exitCode = 4;
+    throw err;
+  }
+
+  if (!res.ok) {
+    let errBody = '';
+    try {
+      errBody = await res.text();
+    } catch (_) {}
+    if (res.status === 401) {
+      const err = new Error(
+        `Brak dostępu do Kosztorysu (HTTP 401). Klucz wygasł lub jest niepoprawny.\nUruchom ponowne logowanie: deertools login estimate`
+      );
+      err.exitCode = 3;
+      throw err;
+    }
+    const err = new Error(`Serwer Kosztorysu zwrócił błąd HTTP ${res.status}: ${errBody || res.statusText}`);
+    err.exitCode = 4;
+    throw err;
+  }
+
+  const json = await res.json();
+  if (json.error) {
+    const err = new Error(`Błąd kalkulacji Kosztorysu: ${json.error.message || JSON.stringify(json.error)}`);
+    err.exitCode = 4;
+    throw err;
+  }
+
+  if (json.result?.structuredContent) {
+    return json.result.structuredContent;
+  }
+  if (json.result?.content?.[0]?.text) {
+    try {
+      return JSON.parse(json.result.content[0].text);
+    } catch (_) {
+      return json.result.content[0].text;
+    }
+  }
+
+  return json.result || {};
+}
+
+async function calculateEstimate(params, options = {}) {
+  return callEstimateMcp('estimate_calculate_simple', params, options);
+}
+
+async function getEstimateMargins(params, options = {}) {
+  return callEstimateMcp('estimate_get_margins', params, options);
+}
+
+module.exports = {
+  callEstimateMcp,
+  calculateEstimate,
+  getEstimateMargins,
+};

package/src/mcp-stdio.js

@@ -5,6 +5,7 @@ const { ALL_PRODUCTS, getProduct } = require('./registry');
 const { apiRequest } = require('./http');
 const { checkSkillUpdates, updateSkills } = require('./skill-commands');
 const skillsHub = require('./skills-hub');
+const { calculateEstimate, getEstimateMargins } = require('./estimate-client');
 
 const PROTOCOL_VERSION = '2024-11-05';
 const SERVER_INFO = { name: 'deertools-stdio-bridge', version: '1.0.5' };
@@ -16,13 +17,19 @@ async function cmdMcpServe(pos, flags) {
     process.stdout.write(JSON.stringify(msg) + '\n');
   }
 
+  let pendingCount = 0;
+  let isClosed = false;
+  let closeResolve = null;
+
   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;
-    }
+    pendingCount++;
+    try {
+      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;
 
@@ -47,12 +54,25 @@ async function cmdMcpServe(pos, flags) {
       const tools = [
         {
           name: 'estimate_calculate',
-          description: 'Szybkie wyliczenie kosztu wykończenia mieszkania z podanego metrażu w pakietach Smart Life, Modern Life, High Life.',
+          description: 'Szybkie wyliczenie kosztu wykończenia mieszkania z podanego metrażu w pakietach Smart Life, Modern Life, High Life (kalkulacja po stronie serwera Kosztorys).',
+          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 (opcjonalny — bez podania zwraca 3 pakiety)' },
+              wet_zones: { type: 'number', description: 'Liczba stref mokrych (np. łazienki, WC)' },
+              doors: { type: 'number', description: 'Liczba kompletów drzwi wewnętrznych' },
+            },
+            required: ['area_m2'],
+          },
+        },
+        {
+          name: 'estimate_get_margins',
+          description: 'Pobiera reguły wyliczania marży i strukturę kosztorysową Deer Design dla zadanego metrażu z serwera Kosztorys.',
           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'],
           },
@@ -161,16 +181,16 @@ async function cmdMcpServe(pos, flags) {
       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);
+          const pkg = args.package;
+          const wetZones = args.wet_zones !== undefined ? Number(args.wet_zones) : undefined;
+          const doors = args.doors !== undefined ? Number(args.doors) : undefined;
+
+          const data = await calculateEstimate({
+            area_m2: area,
+            package: pkg,
+            wet_zones: wetZones,
+            doors: doors,
+          });
 
           send({
             jsonrpc: '2.0',
@@ -178,15 +198,26 @@ async function cmdMcpServe(pos, flags) {
             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),
+                text: JSON.stringify(data, null, 2),
+              }],
+              structuredContent: data,
+            },
+          });
+          return;
+        }
+
+        if (toolName === 'estimate_get_margins') {
+          const area = Number(args.area_m2 || 50);
+          const data = await getEstimateMargins({ area_m2: area });
+          send({
+            jsonrpc: '2.0',
+            id,
+            result: {
+              content: [{
+                type: 'text',
+                text: JSON.stringify(data, null, 2),
               }],
+              structuredContent: data,
             },
           });
           return;
@@ -383,6 +414,23 @@ async function cmdMcpServe(pos, flags) {
     }
 
     send({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } });
+    } finally {
+      pendingCount--;
+      if (isClosed && pendingCount === 0 && closeResolve) {
+        closeResolve();
+      }
+    }
+  });
+
+  rl.on('close', () => {
+    isClosed = true;
+    if (pendingCount === 0 && closeResolve) {
+      closeResolve();
+    }
+  });
+
+  return new Promise((resolve) => {
+    closeResolve = resolve;
   });
 }