@deerdesign/deertools 1.2.9 → 1.2.12

package/README.md

@@ -34,7 +34,7 @@ Requires **Node.js ≥ 18**. Zero runtime dependencies.
 ### Option 1: Run instantly with `npx` (No installation needed)
 
 ```bash
-npx @deerdesign/deertools login catalog
+npx -y @deerdesign/deertools@latest login catalog
 ```
 
 ### Option 2: Install globally

package/docs/prezentacja-it-deertools.md

@@ -54,7 +54,7 @@ deer whoami           # skrócony alias
 
 ### 2. Uruchomienie ad-hoc bez instalacji:
 ```bash
-npx @deerdesign/deertools doctor
+npx -y @deerdesign/deertools@latest doctor
 ```
 
 ### 3. Klonowanie repozytorium (wersja deweloperska):

package/package.json

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

package/src/commands.js

@@ -381,6 +381,9 @@ async function cmdSkill(pos, flags) {
   if (sub === 'push') {
     return skillCommands.cmdSkillPush(pos[1], flags, out, err);
   }
+  if (sub === 'check' || sub === 'status') {
+    return skillCommands.cmdSkillCheck(flags, out, err);
+  }
   if (sub === 'update') {
     return skillCommands.cmdSkillUpdate(flags, out, err);
   }
@@ -396,7 +399,7 @@ async function cmdSkill(pos, flags) {
   if (sub === 'install') {
     return skillCommands.cmdSkillInstall(pos[1], flags, out, err);
   }
-  fail('Użycie:\n  deertools skill login [token]\n  deertools skill bundle <architekci|kosztorysy|logistyka|sprzedaz|it>\n  deertools skill list [--tag <tag>]\n  deertools skill search <fraza>\n  deertools skill install <slug[@version]>\n  deertools skill versions <slug>\n  deertools skill diff <slug> [wersjaA] [wersjaB]\n  deertools skill push [katalog] [--bump patch|minor|major] [--changelog "opis"]\n  deertools skill update\n  deertools skill promote <slug>', 2);
+  fail('Użycie:\n  deertools skill login [token]\n  deertools skill bundle <architekci|kosztorysy|logistyka|sprzedaz|it>\n  deertools skill list [--tag <tag>]\n  deertools skill search <fraza>\n  deertools skill install <slug[@version]>\n  deertools skill check\n  deertools skill update [slug]\n  deertools skill versions <slug>\n  deertools skill diff <slug> [wersjaA] [wersjaB]\n  deertools skill push [katalog] [--bump patch|minor|major] [--changelog "opis"]\n  deertools skill promote <slug>', 2);
 }
 
 

package/src/mcp-stdio.js

@@ -1,8 +1,9 @@
 'use strict';
 const readline = require('readline');
 const credentials = require('./credentials');
-const { ALL_PRODUCTS } = require('./registry');
+const { ALL_PRODUCTS, getProduct } = require('./registry');
 const { apiRequest } = require('./http');
+const { checkSkillUpdates, updateSkills } = require('./skill-commands');
 
 const PROTOCOL_VERSION = '2024-11-05';
 const SERVER_INFO = { name: 'deertools-stdio-bridge', version: '1.0.5' };
@@ -92,6 +93,24 @@ async function cmdMcpServe(pos, flags) {
             required: ['catalog_price_net'],
           },
         },
+        {
+          name: 'deer_check_skill_updates',
+          description: 'Sprawdza czy zainstalowane lokalnie skille AI DeerTools posiadają nowsze wersje w DeerSkills Hub. Zwraca listę skilli z dostępnymi aktualizacjami i ich changelogami.',
+          inputSchema: {
+            type: 'object',
+            properties: {},
+          },
+        },
+        {
+          name: 'deer_update_skills',
+          description: 'Autonomiczna aktualizacja skilli Deer Design — pobiera najnowsze wersje paczek z DeerSkills Hub i odświeża plik blokady.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              slug: { type: 'string', description: 'Opcjonalny slug konkretnego skilla do zaktualizowania (np. deer-kosztorys). Domyślnie aktualizuje wszystkie przestarzałe skille.' },
+            },
+          },
+        },
       ];
 
       send({ jsonrpc: '2.0', id, result: { tools } });
@@ -183,6 +202,52 @@ async function cmdMcpServe(pos, flags) {
           return;
         }
 
+        if (toolName === 'deer_check_skill_updates') {
+          const updates = await checkSkillUpdates();
+          const outdated = updates.filter((u) => u.hasUpdate);
+          send({
+            jsonrpc: '2.0',
+            id,
+            result: {
+              content: [{
+                type: 'text',
+                text: JSON.stringify({
+                  has_updates: outdated.length > 0,
+                  outdated_count: outdated.length,
+                  total_checked: updates.length,
+                  skills: updates,
+                  agent_recommendation: outdated.length > 0
+                    ? `Znaleziono ${outdated.length} przestarzałych skilli. Zapytaj użytkownika: „Czy chcesz, abym zaktualizował skille [${outdated.map((o) => o.slug).join(', ')}] do najnowszych wydań?” i wywołaj deer_update_skills.`
+                    : 'Wszystkie zainstalowane skille są w najnowszych wersjach.',
+                }, null, 2),
+              }],
+            },
+          });
+          return;
+        }
+
+        if (toolName === 'deer_update_skills') {
+          const res = await updateSkills(args.slug || null);
+          send({
+            jsonrpc: '2.0',
+            id,
+            result: {
+              content: [{
+                type: 'text',
+                text: JSON.stringify({
+                  status: 'success',
+                  updated_count: res.updated.length,
+                  updated_skills: res.updated,
+                  message: res.updated.length > 0
+                    ? `Pomyślnie zaktualizowano ${res.updated.length} skilli do najnowszych wydań.`
+                    : 'Wszystkie skille były już w najnowszych wersjach.',
+                }, 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 } });

package/src/skill-commands.js

@@ -1,6 +1,6 @@
-'use strict';
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const { detectAgents, installSkillContent } = require('./agent-detector');
 const skillsHub = require('./skills-hub');
 const { parseFrontmatterName } = require('./openapi');
@@ -9,8 +9,17 @@ const { fetchText } = require('./http');
 
 const LOCK_FILE = '.deertools-lock.json';
 
+function getLockFilePath(cwd = process.cwd()) {
+  const local = path.join(cwd, LOCK_FILE);
+  if (fs.existsSync(local)) return local;
+  const globalDir = path.join(os.homedir(), '.deertools');
+  const globalPath = path.join(globalDir, LOCK_FILE);
+  if (fs.existsSync(globalPath)) return globalPath;
+  return local;
+}
+
 function readLock(cwd = process.cwd()) {
-  const p = path.join(cwd, LOCK_FILE);
+  const p = getLockFilePath(cwd);
   if (fs.existsSync(p)) {
     try {
       return JSON.parse(fs.readFileSync(p, 'utf8'));
@@ -22,6 +31,11 @@ function readLock(cwd = process.cwd()) {
 function writeLock(data, cwd = process.cwd()) {
   const p = path.join(cwd, LOCK_FILE);
   fs.writeFileSync(p, JSON.stringify(data, null, 2) + '\n', 'utf8');
+  try {
+    const globalDir = path.join(os.homedir(), '.deertools');
+    if (!fs.existsSync(globalDir)) fs.mkdirSync(globalDir, { recursive: true });
+    fs.writeFileSync(path.join(globalDir, LOCK_FILE), JSON.stringify(data, null, 2) + '\n', 'utf8');
+  } catch (_) {}
 }
 
 async function cmdSkillList(flags, out, err) {
@@ -142,6 +156,67 @@ async function cmdSkillInstall(target, flags, out, err) {
   };
   writeLock(lock);
   out(`✓ Zaktualizowano ${LOCK_FILE} (wersja ${versionData.version}).`);
+
+  // Podsumowanie możliwości skilla dla użytkownika i Agenta AI
+  printSkillSummary(skill, versionData, out);
+}
+
+function extractCapabilities(content, summary = '') {
+  const text = String(content || '');
+  const lines = text.split('\n');
+  const bullets = [];
+  let inWhen = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (/^##\s+(Kiedy używać|Możliwości|Zastosowanie|Co potrafi)/i.test(line)) {
+      inWhen = true;
+      continue;
+    }
+    if (inWhen) {
+      if (/^##\s+/.test(line)) break;
+      if (line.startsWith('- ') || line.startsWith('* ') || /^\d+\.\s+/.test(line)) {
+        const clean = line.replace(/^[-*]\s+|\d+\.\s+/, '').replace(/\.$/, '').trim();
+        if (clean.length > 5 && !clean.toLowerCase().startsWith('nie używaj')) {
+          bullets.push(clean);
+        }
+      }
+    }
+  }
+
+  const desc = summary || (text.match(/description:\s*["']?([^"'\n]+)/i)?.[1]) || '';
+  return { desc, bullets: bullets.slice(0, 4) };
+}
+
+function printSkillSummary(skill, versionData, out) {
+  const { desc, bullets } = extractCapabilities(versionData.skill_md_content, skill.summary);
+  const manifest = versionData.files_manifest || [];
+
+  out('\n\x1b[36m┌─────────────────────────────────────────────────────────────────────────────┐\x1b[0m');
+  out(`\x1b[36m│\x1b[0m  \x1b[1m🚀 NOWA UMIEJĘTNOŚĆ AGENTA: ${skill.full_slug || skill.slug} (v${versionData.version})\x1b[0m`);
+  out('\x1b[36m├─────────────────────────────────────────────────────────────────────────────┤\x1b[0m');
+
+  if (desc) {
+    const shortDesc = desc.length > 180 ? `${desc.slice(0, 177)}...` : desc;
+    out(`\x1b[36m│\x1b[0m  \x1b[33mOpis roli:\x1b[0m ${shortDesc}`);
+  }
+
+  if (bullets.length > 0) {
+    out(`\x1b[36m│\x1b[0m  \x1b[32mCo potrafi ten skill (Kiedy używać):\x1b[0m`);
+    for (const b of bullets) {
+      out(`\x1b[36m│\x1b[0m    • ${b}`);
+    }
+  }
+
+  if (manifest.length > 0) {
+    const fileList = manifest.map((f) => path.basename(f.path)).slice(0, 5).join(' · ');
+    const more = manifest.length > 5 ? ` (+${manifest.length - 5} więcej)` : '';
+    out(`\x1b[36m│\x1b[0m  \x1b[34mDołączone referencje w paczce (${manifest.length} plików):\x1b[0m ${fileList}${more}`);
+  }
+
+  out('\x1b[36m├─────────────────────────────────────────────────────────────────────────────┤\x1b[0m');
+  out('\x1b[36m│\x1b[0m  \x1b[90m💡 Informacja dla Agenta AI: Twój asystent może natychmiast korzystać z tych reguł.\x1b[0m');
+  out('\x1b[36m└─────────────────────────────────────────────────────────────────────────────┘\x1b[0m\n');
 }
 
 async function cmdSkillPush(dir, flags, out, err) {
@@ -297,39 +372,88 @@ async function cmdSkillDiff(args, flags, out, err) {
   out('');
 }
 
-async function cmdSkillUpdate(flags, out, err) {
-  const lock = readLock();
+async function checkSkillUpdates(cwd = process.cwd()) {
+  const lock = readLock(cwd);
   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;
+  const results = [];
 
   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.`);
-        }
+      if (res.ok) {
+        const latestVer = res.data?.skill?.latest_version || res.data?.version?.version || res.data?.latest_version;
+        const changelog = res.data?.selected_version?.changelog || res.data?.skill?.changelog || '';
+        const title = res.data?.skill?.title || slug;
+        const hasUpdate = latestVer && latestVer !== current.version;
+        results.push({
+          slug,
+          title,
+          currentVersion: current.version,
+          latestVersion: latestVer,
+          hasUpdate: !!hasUpdate,
+          changelog,
+          installedAt: current.installedAt,
+        });
       }
+    } catch (_) {}
+  }
+  return results;
+}
+
+async function updateSkills(slugFilter = null, flags = {}, out = () => {}, err = () => {}) {
+  const updates = await checkSkillUpdates();
+  const toUpdate = slugFilter
+    ? updates.filter((u) => u.slug === slugFilter && u.hasUpdate)
+    : updates.filter((u) => u.hasUpdate);
+
+  const updated = [];
+  for (const item of toUpdate) {
+    try {
+      out(`Aktualizacja ${item.slug}: ${item.currentVersion} → ${item.latestVersion}...`);
+      await cmdSkillInstall(`${item.slug}@${item.latestVersion}`, flags, out, err);
+      updated.push({ slug: item.slug, from: item.currentVersion, to: item.latestVersion });
     } catch (e) {
-      err(`✗ Błąd sprawdzania ${slug}: ${e.message}`);
+      err(`✗ Błąd aktualizacji ${item.slug}: ${e.message}`);
     }
   }
+  return { updated, checked: updates.length, totalOutdated: updates.filter((u) => u.hasUpdate).length };
+}
+
+async function cmdSkillCheck(flags, out, err) {
+  out('Sprawdzam wersje zainstalowanych skilli w DeerSkills Hub...');
+  const updates = await checkSkillUpdates();
+  if (updates.length === 0) {
+    out('Brak zainstalowanych skilli w pliku .deertools-lock.json.');
+    return;
+  }
+
+  const outdated = updates.filter((u) => u.hasUpdate);
+  if (outdated.length === 0) {
+    out(`✓ Wszystkie zainstalowane skille (${updates.length}) są w najnowszych wersjach.`);
+    return;
+  }
+
+  out(`\nZnaleziono aktualizacje dla ${outdated.length} z ${updates.length} skilli:\n`);
+  for (const item of outdated) {
+    out(`  • \x1b[1m${item.slug}\x1b[0m: ${item.currentVersion} → \x1b[32mv${item.latestVersion}\x1b[0m`);
+    if (item.changelog) out(`    Changelog: \x1b[33m${item.changelog}\x1b[0m`);
+  }
+  out(`\nAby zaktualizować wszystkie, uruchom: \x1b[36mdeertools skill update\x1b[0m\n`);
+}
+
+async function cmdSkillUpdate(flags, out, err) {
+  const targetSlug = typeof flags === 'string' ? flags : (flags.slug || null);
+  out('Sprawdzam aktualizacje w DeerSkills Hub...');
+  const res = await updateSkills(targetSlug, flags, out, err);
+
+  if (res.checked === 0) {
+    out('Brak zainstalowanych skilli w pliku .deertools-lock.json.');
+    return;
+  }
 
-  if (updatedCount > 0) {
-    out(`\n✓ Zaktualizowano pomyślnie ${updatedCount} skilli.`);
+  if (res.updated.length > 0) {
+    out(`\n✓ Zaktualizowano pomyślnie ${res.updated.length} skilli.`);
   } else {
     out('\nWszystkie zainstalowane skille są w najnowszych wersjach.');
   }
@@ -356,8 +480,11 @@ module.exports = {
   cmdSkillSearch,
   cmdSkillInstall,
   cmdSkillPush,
+  cmdSkillCheck,
   cmdSkillUpdate,
   cmdSkillPromote,
   cmdSkillVersions,
   cmdSkillDiff,
+  checkSkillUpdates,
+  updateSkills,
 };

package/src/skills-hub.js

@@ -87,7 +87,8 @@ async function listSkills(params = {}) {
 }
 
 async function getSkill(slug, version = null) {
-  const qs = version ? `?version=${encodeURIComponent(version)}` : '';
+  const ver = typeof version === 'object' && version !== null ? version.version : version;
+  const qs = ver ? `?version=${encodeURIComponent(ver)}` : '';
   return hubRequest(`/skills/${encodeURIComponent(slug)}${qs}`);
 }
 

package/src/updater.js

@@ -95,7 +95,8 @@ function printUpdateNotice(updateInfo) {
   process.stderr.write(`\x1b[33m└${border}┘\x1b[0m\n\n`);
 }
 
-async function cmdUpdate(pos, flags) {
+async function cmdUpdate(pos, flags = {}) {
+  const shouldInstall = flags.install || flags.i || flags.yes || flags.y;
   process.stdout.write(`Sprawdzam aktualizacje w rejestrze npm...\n`);
   const latest = await fetchLatestVersion();
   if (!latest) {
@@ -104,13 +105,35 @@ async function cmdUpdate(pos, flags) {
   }
 
   const cmp = compareSemver(latest, PKG.version);
-  if (cmp <= 0) {
+  if (cmp <= 0 && !flags.force) {
     process.stdout.write(`✓ DeerTools CLI jest w najnowszej wersji (${PKG.version}).\n`);
     return 0;
   }
 
-  process.stdout.write(`\nZnaleziono nowszą wersję: ${PKG.version} → \x1b[32m${latest}\x1b[0m\n\n`);
-  process.stdout.write(`Aby zaktualizować instalację globalną, uruchom:\n`);
+  if (cmp > 0) {
+    process.stdout.write(`\nZnaleziono nowszą wersję: ${PKG.version} → \x1b[32m${latest}\x1b[0m\n\n`);
+  } else if (flags.force) {
+    process.stdout.write(`\nWymuszam ponowną instalację wersji: \x1b[32m${latest}\x1b[0m\n\n`);
+  }
+
+  if (shouldInstall) {
+    process.stdout.write(`Uruchamiam: npm install -g @deerdesign/deertools@latest...\n`);
+    const { spawnSync } = require('child_process');
+    const res = spawnSync('npm', ['install', '-g', '@deerdesign/deertools@latest'], {
+      stdio: 'inherit',
+    });
+    if (res.status === 0) {
+      process.stdout.write(`\n✓ Pomyślnie zaktualizowano DeerTools CLI do wersji v${latest}!\n`);
+      return 0;
+    } else {
+      process.stdout.write(`\n✗ Błąd instalacji (kod wyjścia: ${res.status}).\nJeśli instalacja wymaga uprawnień roota, uruchom:\n  sudo npm install -g @deerdesign/deertools@latest\n\n`);
+      return res.status || 1;
+    }
+  }
+
+  process.stdout.write(`Aby zaktualizować instalację globalną automatycznie, uruchom:\n`);
+  process.stdout.write(`  \x1b[36mdeertools update --install\x1b[0m (lub \x1b[36mdeertools update -y\x1b[0m)\n\n`);
+  process.stdout.write(`Lub bezpośrednio przez npm:\n`);
   process.stdout.write(`  \x1b[36mnpm install -g @deerdesign/deertools@latest\x1b[0m\n\n`);
   process.stdout.write(`Jeśli instalacja wymaga uprawnień administratora:\n`);
   process.stdout.write(`  \x1b[36msudo npm install -g @deerdesign/deertools@latest\x1b[0m\n\n`);