@deerdesign/deertools 1.2.13 → 1.2.21

package/src/skill-commands.js

@@ -7,6 +7,8 @@ const { parseFrontmatterName } = require('./openapi');
 const { resolveProducts } = require('./registry');
 const { fetchText } = require('./http');
 
+const { compareSemver } = require('./updater');
+
 const LOCK_FILE = '.deertools-lock.json';
 
 function getLockFilePath(cwd = process.cwd()) {
@@ -38,14 +40,149 @@ function writeLock(data, cwd = process.cwd()) {
   } catch (_) {}
 }
 
+/**
+ * Szuka pliku skilla na dysku dla danego agenta.
+ */
+function findSkillFileForAgent(agent, skill) {
+  const slug = skill.slug;
+  const fullSlug = skill.full_slug || slug;
+  const shortSlug = slug.replace(/^@[^/]+\//, '');
+
+  if (agent.format === 'cursor_mdc') {
+    const candidates = [
+      path.join(agent.targetDir, `${slug}.mdc`),
+      path.join(agent.targetDir, `${shortSlug}.mdc`),
+      path.join(agent.targetDir, `${fullSlug.replace(/\//g, '-')}.mdc`),
+    ];
+    for (const c of candidates) {
+      if (fs.existsSync(c)) return c;
+    }
+    return null;
+  }
+
+  const candidates = [
+    path.join(agent.targetDir, slug, 'SKILL.md'),
+    path.join(agent.targetDir, shortSlug, 'SKILL.md'),
+    path.join(agent.targetDir, fullSlug, 'SKILL.md'),
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+/**
+ * Wyciąga wersję z pliku SKILL.md lub .mdc z fallbackiem na lockfile.
+ */
+function readSkillVersion(filePath, lock, skill) {
+  if (!filePath || !fs.existsSync(filePath)) return null;
+  try {
+    const head = fs.readFileSync(filePath, 'utf8').slice(0, 2048);
+    const m = head.match(/[\r\n]version:\s*['"]?([0-9]+\.[0-9]+(\.[0-9]+)?(-[a-zA-Z0-9.]+)?)/i)
+      || head.match(/^version:\s*['"]?([0-9]+\.[0-9]+(\.[0-9]+)?(-[a-zA-Z0-9.]+)?)/im);
+    if (m && m[1]) return m[1];
+    const vMatch = head.match(/v([0-9]+\.[0-9]+(\.[0-9]+)?)/i);
+    if (vMatch && vMatch[1]) return vMatch[1];
+  } catch (_) {}
+
+  if (lock?.skills) {
+    const lockEntry = lock.skills[skill.slug] || lock.skills[skill.full_slug];
+    if (lockEntry && lockEntry.version) return lockEntry.version;
+  }
+  return '1.0.0';
+}
+
+/**
+ * Bada stan instalacji i wersję skilla u wszystkich zadanych agentów.
+ */
+function inspectSkillForAgents(agents, skill, lock) {
+  const agentStatuses = {};
+  let installedCount = 0;
+  let upToDateCount = 0;
+  let outdatedCount = 0;
+  let missingCount = 0;
+
+  for (const agent of agents) {
+    const filePath = findSkillFileForAgent(agent, skill);
+    if (!filePath) {
+      agentStatuses[agent.id] = {
+        agentId: agent.id,
+        agentName: agent.name,
+        installed: false,
+        version: null,
+        status: 'missing',
+        filePath: null,
+        badge: `\x1b[90m[○ ${agent.id}: brak]\x1b[0m`,
+      };
+      missingCount += 1;
+      continue;
+    }
+
+    installedCount += 1;
+    const installedVer = readSkillVersion(filePath, lock, skill);
+    const cmp = compareSemver(installedVer, skill.latest_version);
+
+    if (cmp >= 0) {
+      agentStatuses[agent.id] = {
+        agentId: agent.id,
+        agentName: agent.name,
+        installed: true,
+        version: installedVer,
+        status: 'up_to_date',
+        filePath,
+        badge: `\x1b[32m[✓ ${agent.id}: v${installedVer}]\x1b[0m`,
+      };
+      upToDateCount += 1;
+    } else {
+      agentStatuses[agent.id] = {
+        agentId: agent.id,
+        agentName: agent.name,
+        installed: true,
+        version: installedVer,
+        status: 'outdated',
+        target_version: skill.latest_version,
+        filePath,
+        badge: `\x1b[33m[↑ ${agent.id}: v${installedVer} → v${skill.latest_version}]\x1b[0m`,
+      };
+      outdatedCount += 1;
+    }
+  }
+
+  let overallStatus = 'missing';
+  let overallBadge = '\x1b[90m[○ Niezainstalowany]\x1b[0m';
+
+  if (installedCount > 0) {
+    if (installedCount === agents.length && outdatedCount === 0) {
+      overallStatus = 'up_to_date';
+      overallBadge = `\x1b[32m[✓ Aktualny (${installedCount}/${agents.length})]\x1b[0m`;
+    } else if (outdatedCount > 0) {
+      overallStatus = 'outdated';
+      overallBadge = `\x1b[33m[↑ Wymaga aktualizacji (${outdatedCount})]\x1b[0m`;
+    } else {
+      overallStatus = 'partial';
+      overallBadge = `\x1b[36m[◐ Częściowy (${installedCount}/${agents.length})]\x1b[0m`;
+    }
+  }
+
+  return {
+    agents: agentStatuses,
+    installedCount,
+    upToDateCount,
+    outdatedCount,
+    missingCount,
+    overallStatus,
+    overallBadge,
+  };
+}
+
 async function cmdSkillList(flags, out, err) {
-  out('Pobieram listę skilli z DeerSkills Hub...');
+  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 || 50,
+    limit: flags.limit || 100,
   });
 
   if (!res.ok) {
@@ -54,66 +191,133 @@ async function cmdSkillList(flags, out, err) {
   }
 
   const items = Array.isArray(res.data) ? res.data : (res.data?.skills || []);
+  const agents = detectAgents({
+    dir: flags.dir,
+    agent: flags.agent,
+    'all-agents': flags['all-agents'],
+  });
+  const lock = readLock(flags.dir);
+
   if (flags.json) {
-    out(JSON.stringify(items, null, 2));
+    const enriched = items.map((s) => {
+      const insp = inspectSkillForAgents(agents, s, lock);
+      return {
+        ...s,
+        overall_status: insp.overallStatus,
+        agents: Object.fromEntries(
+          Object.entries(insp.agents).map(([id, data]) => [
+            id,
+            {
+              installed: data.installed,
+              version: data.version,
+              status: data.status,
+              target_version: data.target_version || null,
+              file_path: data.filePath,
+            },
+          ])
+        ),
+      };
+    });
+    out(JSON.stringify(enriched, null, 2));
     return;
   }
 
+  const agentSummary = {};
+  for (const a of agents) {
+    agentSummary[a.id] = {
+      name: a.name,
+      targetDir: a.targetDir,
+      total: items.length,
+      upToDate: 0,
+      outdated: 0,
+      missing: 0,
+    };
+  }
+
   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)}...`);
+    const latestVer = s.latest_version ? `v${s.latest_version}` : 'v1.0.0';
+    const insp = inspectSkillForAgents(agents, s, lock);
+
+    for (const a of agents) {
+      const st = insp.agents[a.id];
+      if (st.status === 'up_to_date') agentSummary[a.id].upToDate += 1;
+      else if (st.status === 'outdated') agentSummary[a.id].outdated += 1;
+      else agentSummary[a.id].missing += 1;
+    }
+
+    const agentBadges = agents.map((a) => insp.agents[a.id].badge).join(' ');
+
+    out(`  • ${s.full_slug.padEnd(36)} ${latestVer.padEnd(10)} ${badge.padEnd(14)} ${insp.overallBadge}`);
+    out(`    Agenci: ${agentBadges}`);
+    if (s.summary) out(`    ${s.summary.slice(0, 95)}...`);
     if (s.tags && s.tags.length) out(`    Tagi: ${s.tags.join(', ')}`);
     out('');
   }
+
+  out('─'.repeat(78));
+  out(`📊 Stan platform agentów AI / lokalnego środowiska agenta:`);
+  let anyOutdated = false;
+  let anyMissing = false;
+
+  for (const a of agents) {
+    const sum = agentSummary[a.id];
+    if (sum.outdated > 0) anyOutdated = true;
+    if (sum.missing > 0) anyMissing = true;
+
+    let badgeText = '';
+    if (sum.upToDate === sum.total) {
+      badgeText = `\x1b[32m${sum.upToDate}/${sum.total} aktualne\x1b[0m`;
+    } else {
+      const parts = [];
+      if (sum.upToDate > 0) parts.push(`\x1b[32m${sum.upToDate} aktualne\x1b[0m`);
+      if (sum.outdated > 0) parts.push(`\x1b[33m${sum.outdated} do aktualizacji\x1b[0m`);
+      if (sum.missing > 0) parts.push(`\x1b[90m${sum.missing} brak\x1b[0m`);
+      badgeText = parts.join(', ');
+    }
+    out(`   • ${(a.name + ' (' + a.id + '):').padEnd(36)} ${badgeText}`);
+  }
+
+  if (anyOutdated || anyMissing) {
+    out(`\n💡 Aby zainstalować brakujące i zaktualizować wszystkie skille u agentów:`);
+    out(`   \x1b[36mdeertools skill sync\x1b[0m   (lub: \x1b[36mdeertools sync\x1b[0m)`);
+  } else {
+    out(`\n✓ Wszystkie skille zespołu (${items.length}) są zainstalowane i aktualne u wszystkich wykrytych agentów.`);
+  }
+  out('─'.repeat(78) + '\n');
 }
 
 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;
-  }
+/**
+ * Instaluje pojedynczy skill z DeerSkills Hub.
+ */
+async function installSingleSkill(slug, requestedVersion, flags, out, err, { silentSummary = false } = {}) {
+  const legacyMap = {
+    estimate: 'deer-kosztorys',
+    catalog: 'deer-catalog',
+    deliveries: 'deertools-dostawy',
+    supplier: 'deertools-supplier-hub',
+    rendermind: 'rendermind',
+  };
+  const resolvedSlug = legacyMap[slug] || slug;
 
-  // 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 (!silentSummary) {
+    out(`Pobieram skill „${resolvedSlug}”${requestedVersion ? ` w wersji ${requestedVersion}` : ''} z DeerSkills Hub...`);
+  }
+  const res = await skillsHub.getSkill(resolvedSlug, requestedVersion);
 
   if (!res.ok || !res.data?.skill) {
-    throw new Error(`Nie znaleziono skilla „${slug}” w DeerSkills Hub (${res.status}): ${res.data?.error || 'Błąd'}`);
+    throw new Error(`Nie znaleziono skilla „${resolvedSlug}” w DeerSkills Hub (${res.status}): ${res.data?.error || 'Błąd'}`);
   }
 
   const skill = res.data.skill;
   const versionData = res.data.selected_version || res.data.version || (res.data.versions && res.data.versions[0]);
   if (!versionData) {
-    throw new Error(`Brak opublikowanej wersji dla skilla „${slug}”.`);
+    throw new Error(`Brak opublikowanej wersji dla skilla „${resolvedSlug}”.`);
   }
   const agents = detectAgents({ dir: flags.dir, agent: flags.agent });
 
@@ -125,12 +329,14 @@ async function cmdSkillInstall(target, flags, out, err) {
   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}`);
+      if (!silentSummary) {
+        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);
+        const baseDir = agent.format === 'cursor_mdc' ? path.join(agent.targetDir, skill.slug) : path.dirname(dest);
         for (const file of versionData.files_manifest) {
           const targetFile = path.join(baseDir, file.path);
           fs.mkdirSync(path.dirname(targetFile), { recursive: true });
@@ -147,18 +353,112 @@ async function cmdSkillInstall(target, flags, out, err) {
   }
 
   // Zapis do .deertools-lock.json
-  const lock = readLock();
+  const lock = readLock(flags.dir);
   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}).`);
+  writeLock(lock, flags.dir);
+
+  if (!silentSummary) {
+    out(`✓ Zaktualizowano ${LOCK_FILE} (wersja ${versionData.version}).`);
+    printSkillSummary(skill, versionData, out);
+  }
 
-  // Podsumowanie możliwości skilla dla użytkownika i Agenta AI
-  printSkillSummary(skill, versionData, out);
+  return { skill, versionData, count };
+}
+
+/**
+ * Instaluje lub synchronizuje wszystkie skille zespołu z DeerSkills Hub.
+ */
+async function cmdSkillSync(flags, out, err) {
+  out('Pobieram pełną listę skilli zespołu z DeerSkills Hub...');
+  const res = await skillsHub.listSkills({ limit: 100 });
+  if (!res.ok) {
+    err(`✗ Błąd pobierania katalogu skilli (${res.status}): ${res.data?.error || 'Brak dostępu'}`);
+    return;
+  }
+  const items = Array.isArray(res.data) ? res.data : (res.data?.skills || []);
+  if (items.length === 0) {
+    out('Brak skilli w DeerSkills Hub.');
+    return;
+  }
+
+  let agents = detectAgents({ dir: flags.dir, agent: flags.agent });
+  if (flags.i || flags.interactive || flags.select) {
+    const { promptSelectAgents } = require('./agent-detector');
+    const available = detectAgents({ dir: flags.dir, 'ignore-selected': true });
+    agents = await promptSelectAgents(available);
+    flags = { ...flags, agent: agents.map((a) => a.id).join(',') };
+  }
+
+  if (agents.length === 0) {
+    err('✗ Nie wybrano ani nie wykryto żadnego środowiska agenta AI.');
+    return;
+  }
+
+  const lock = readLock(flags.dir);
+  out(`Platformy docelowe: \x1b[36m${agents.map((a) => a.name || a.id).join(', ')}\x1b[0m`);
+  out(`Rozpoczynam synchronizację ${items.length} skilli zespołu...\n`);
+
+  let installedCount = 0;
+  let updatedCount = 0;
+  let unchangedCount = 0;
+  let failedCount = 0;
+
+  for (const s of items) {
+    const slug = s.slug;
+    const fullSlug = s.full_slug;
+    const current = lock.skills?.[slug] || lock.skills?.[fullSlug];
+    const currentVer = current?.version;
+    const latestVer = s.latest_version || '1.0.0';
+
+    if (currentVer && currentVer === latestVer && !flags.force) {
+      out(`  \x1b[32m✓\x1b[0m ${s.full_slug.padEnd(38)} v${currentVer.padEnd(8)} [Aktualny]`);
+      unchangedCount += 1;
+      continue;
+    }
+
+    try {
+      await installSingleSkill(s.full_slug || s.slug, latestVer, flags, out, err, { silentSummary: true });
+      if (currentVer) {
+        out(`  \x1b[33m↑\x1b[0m ${s.full_slug.padEnd(38)} v${latestVer.padEnd(8)} [Zaktualizowano z v${currentVer}]`);
+        updatedCount += 1;
+      } else {
+        out(`  \x1b[36m+\x1b[0m ${s.full_slug.padEnd(38)} v${latestVer.padEnd(8)} [Zainstalowano]`);
+        installedCount += 1;
+      }
+    } catch (e) {
+      out(`  \x1b[31m✗\x1b[0m ${s.full_slug.padEnd(38)} Błąd: ${e.message}`);
+      failedCount += 1;
+    }
+  }
+
+  out('\n' + '─'.repeat(72));
+  out(`\x1b[1m✓ Podsumowanie synchronizacji ekosystemu Deer Design:\x1b[0m`);
+  out(`   • Nowo zainstalowane:       \x1b[36m${installedCount}\x1b[0m`);
+  out(`   • Zaktualizowane:          \x1b[33m${updatedCount}\x1b[0m`);
+  out(`   • Aktualne bez zmian:      \x1b[32m${unchangedCount}\x1b[0m`);
+  if (failedCount > 0) {
+    out(`   • Błędy instalacji:        \x1b[31m${failedCount}\x1b[0m`);
+  }
+  out(`   • Agenci docelowi:         ${agents.map((a) => a.id).join(', ')}`);
+  out(`   • Zapisano w rejestrze:    ${LOCK_FILE}`);
+  out('─'.repeat(72) + '\n');
+}
+
+async function cmdSkillInstall(target, flags, out, err) {
+  let [slug, requestedVersion] = String(target || '').split('@');
+  slug = (slug || '').trim();
+
+  // Jeśli brak argumentu lub "all" / "--all" / "team" / "*" lub flaga --all, synchronizuj wszystkie
+  if (!slug || slug === 'all' || slug === '--all' || slug === 'team' || slug === '*' || flags.all) {
+    return cmdSkillSync(flags, out, err);
+  }
+
+  await installSingleSkill(slug, requestedVersion, flags, out, err);
 }
 
 function extractCapabilities(content, summary = '') {
@@ -223,15 +523,41 @@ async function cmdSkillPush(dir, flags, out, err) {
   const targetDir = dir || process.cwd();
   out(`Analizuję folder skilla: ${targetDir}...`);
 
+  const isUserScope = Boolean(flags.own || flags.user || flags['own-space'] || flags.space === 'user');
+  const isGlobalScope = Boolean(flags.global || flags.space === 'global');
+  const isTeamScope = Boolean(flags.team || flags.space === 'team');
+  const scope = isUserScope ? 'user' : (isGlobalScope ? 'global' : (isTeamScope ? 'team' : null));
+  const team = flags.team || flags.t || null;
+
+  const visibility = flags.private ? 'private' : (flags.shared || flags.public ? 'shared' : null);
+
+  let cliTags = null;
+  if (flags.tags) {
+    cliTags = String(flags.tags).split(',').map((t) => t.trim()).filter(Boolean);
+  } else if (flags.tag) {
+    cliTags = (Array.isArray(flags.tag) ? flags.tag : [flags.tag]).flatMap((t) => String(t).split(',')).map((t) => t.trim()).filter(Boolean);
+  }
+
   const res = await skillsHub.pushSkill(targetDir, {
     version: flags.version || null,
     bump: flags.bump || (flags.major ? 'major' : flags.minor ? 'minor' : 'patch'),
     changelog: flags.changelog || flags.message || flags.m || null,
-    visibility: flags.private ? 'private' : 'shared',
+    visibility,
+    scope,
+    namespace: flags.namespace || null,
+    team,
+    tags: cliTags,
   });
 
   if (!res.ok) {
-    throw new Error(`Nie udało się opublikować skilla (${res.status}): ${res.data?.error || 'Błąd serwera'}`);
+    const errMsg = res.data?.error || '';
+    if (res.status === 403 && (errMsg.includes('global') || errMsg.includes('Administrator') || errMsg.includes('firmow') || isGlobalScope)) {
+      throw new Error(`BŁĄD UPRAWNIEŃ (403): Tylko Administrator może publikować do przestrzeni firmowej (global).
+Jako pracownik możesz publikować do swojej przestrzeni prywatnej (@twoj-login/slug) lub do zespołu (--team <zespół>).
+Aby zgłosić swój skill do katalogu firmowego, użyj polecenia:
+  deertools skill promote <nazwa-skilla>`);
+    }
+    throw new Error(`Nie udało się opublikować skilla (${res.status}): ${errMsg || 'Błąd serwera'}`);
   }
 
   const skill = res.data.skill || res.data || {};
@@ -241,17 +567,77 @@ async function cmdSkillPush(dir, flags, out, err) {
     ? res.data.pushed_manifest_count
     : (res.data.version?.files_manifest?.length || 0);
 
+  let scopeLabel;
+  if (skill.scope === 'global') {
+    scopeLabel = '★ Globalna firmy (katalog oficjalny)';
+  } else if (skill.scope === 'team' || team) {
+    scopeLabel = `👥 Zespół: \x1b[36m${team || skill.team_id || 'przypisany'}\x1b[0m`;
+  } else {
+    scopeLabel = `@${skill.namespace || 'własna'}`;
+  }
+
+  let visibilityLabel;
+  if (skill.scope === 'team' || team) {
+    visibilityLabel = '\x1b[32m👥 Współdzielona z zespołem (natychmiastowy dostęp dla członków zespołu)\x1b[0m';
+  } else if (skill.visibility === 'private' || skill.scope === 'user') {
+    visibilityLabel = '\x1b[33m🔒 Prywatna (dostępna tylko dla Ciebie)\x1b[0m';
+  } else {
+    visibilityLabel = '\x1b[32m🌐 Współdzielona z zespołem\x1b[0m';
+  }
+
   out(`\n✓ Pomyślnie opublikowano skill w DeerSkills Hub:`);
   out(`  • Identyfikator: \x1b[1m${skill.full_slug || skill.slug}\x1b[0m`);
+  out(`  • Przestrzeń:    ${scopeLabel}`);
   out(`  • Wersja:        \x1b[32mv${versionNum}\x1b[0m`);
   if (changelog && changelog !== versionNum) {
     out(`  • Changelog:     \x1b[33m${changelog}\x1b[0m`);
   }
   out(`  • Paczka:        ${manifestCount + 1} plików (SKILL.md + ${manifestCount} plików w podkatalogach)`);
-  out(`  • Widoczność:    ${skill.visibility || 'shared'}`);
+  if (skill.tags && Array.isArray(skill.tags) && skill.tags.length > 0) {
+    out(`  • Tagi:          ${skill.tags.map((t) => `\x1b[36m#${t}\x1b[0m`).join(' ')}`);
+  }
+  out(`  • Widoczność:    ${visibilityLabel}`);
   out(`\nAby zainstalować tę wersję w projekcie:\n  \x1b[36mdeertools skill install ${skill.full_slug || skill.slug}@${versionNum}\x1b[0m\n`);
 }
 
+/**
+ * Udostępnia skill wskazanemu zespołowi lub przywraca prywatność.
+ */
+async function cmdSkillShare(slug, flags, out, err) {
+  if (!slug) throw new Error('Podaj slug skilla, np. deertools skill share my-skill --team architekci');
+  const team = flags.team || flags.t || null;
+  const makePrivate = Boolean(flags.private || flags.unshare);
+
+  if (!team && !makePrivate) {
+    let availableTeams = '';
+    try {
+      const teamsRes = await skillsHub.listTeams();
+      if (Array.isArray(teamsRes.data)) {
+        availableTeams = teamsRes.data.map((t) => `    • \x1b[36m${t.slug.padEnd(14)}\x1b[0m (${t.name})`).join('\n');
+      }
+    } catch (_) {}
+    if (!availableTeams) {
+      availableTeams = '    • architekci, kosztorysy, logistyka, sprzedaz, it-dev';
+    }
+
+    throw new Error(`Podaj zespół do udostępnienia (--team <nazwa>) lub flagę --private.\nDostępne zespoły:\n${availableTeams}`);
+  }
+
+  out(`Aktualizuję udostępnienie skilla „${slug}”...`);
+  const res = await skillsHub.shareSkill(slug, { team, makePrivate });
+  if (!res.ok) {
+    throw new Error(`Nie udało się zaktualizować udostępnienia (${res.status}): ${res.data?.error || 'Błąd'}`);
+  }
+
+  if (makePrivate) {
+    out(`\n\x1b[33m🔒 Skill „${slug}” jest teraz prywatny (dostępny wyłącznie dla Ciebie).\x1b[0m\n`);
+  } else {
+    out(`\n\x1b[32m✓ Skill „${slug}” został pomyślnie udostępniony dla zespołu: \x1b[1m${team}\x1b[0m\x1b[0m`);
+    out(`  Wszyscy członkowie zespołu mają do niego natychmiastowy dostęp bez konieczności akceptacji admina.`);
+    out(`  Mogą go zainstalować za pomocą: \x1b[36mdeertools skill install ${slug}\x1b[0m\n`);
+  }
+}
+
 async function cmdSkillVersions(slug, flags, out, err) {
   if (!slug) throw new Error('Podaj slug skilla, np. deertools skill versions deer-technical-documentation');
   out(`Pobieram historię wydań dla skilla „${slug}”...`);
@@ -472,19 +858,131 @@ async function cmdSkillPromote(slug, flags, out, err) {
   }
 
   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');
+  out('  Możesz śledzić status w panelu DeerSkills: https://skills.deergroup.pl/settings\n');
+}
+
+async function cmdSkillReview(args, flags, out, err) {
+  const sub = String(args[0] || 'list').toLowerCase();
+
+  // 1. Zgłoszenie do review
+  if (sub === 'submit') {
+    const slug = args[1] || flags.slug;
+    if (!slug) throw new Error('Podaj slug skilla do zgłoszenia, np. deertools skill review submit @mariusz.szostak/moj-skill');
+    out(`Zgłaszam skill „${slug}” do Peer Review w DeerSkills Hub...`);
+    const res = await skillsHub.submitReview(slug);
+    if (!res.ok) {
+      throw new Error(`Błąd zgłoszenia (${res.status}): ${res.data?.error || 'Brak uprawnień'}`);
+    }
+    out(`\n✓ Skill „${slug}” został pomyślnie zgłoszony do Peer Review!`);
+    out(`  Status: \x1b[33mOczekuje na weryfikację (in_review)\x1b[0m`);
+    out(`  Zatwierdzenie przez leada udostępnia skill w zespole, a zatwierdzenie przez Administratora publikuje do katalogu firmowego.\n`);
+    return;
+  }
+
+  // 2. Zatwierdzenie (Approve)
+  if (sub === 'approve' || sub === 'accept') {
+    const target = args[1] || flags.slug || flags.id;
+    if (!target) throw new Error('Podaj identyfikator lub slug zgłoszonego skilla, np. deertools skill review approve deer-technical-documentation');
+    const notes = flags.notes || flags.message || flags.m || '';
+    out(`Zatwierdzam zgłoszenie dla „${target}”...`);
+    const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(target);
+    const res = await skillsHub.decideReview({
+      slug: isUuid ? null : target,
+      reviewId: isUuid ? target : null,
+      approve: true,
+      notes,
+    });
+    if (!res.ok) {
+      throw new Error(`Błąd zatwierdzania (${res.status}): ${res.data?.error || 'Brak uprawnień lub błąd serwera'}`);
+    }
+    const skill = res.data?.skill || res.data || {};
+    const isGlobal = skill.scope === 'global';
+    out(`\n\x1b[32m✓ Skill ${skill.full_slug || skill.title || target} został ZATWIERDZONY w Peer Review!\x1b[0m`);
+    out(`  • Status:      \x1b[32mZweryfikowany (approved / verified)\x1b[0m`);
+    out(`  • Zasięg:       ${isGlobal ? '★ Globalny (przestrzeń firmowa)' : `👥 Zespołowy: ${skill.team_id || 'zespół'}`}`);
+    out(`  • Wersja:       v${skill.latest_version}`);
+    if (notes) out(`  • Notatka:      ${notes}`);
+    out(`\nKażdy agent może teraz zainstalować skill:\n  \x1b[36mdeertools skill install ${skill.full_slug || skill.slug}\x1b[0m\n`);
+    return;
+  }
+
+  // 3. Odrzucenie / prośba o poprawki (Request Changes)
+  if (sub === 'reject' || sub === 'changes' || sub === 'request-changes') {
+    const target = args[1] || flags.slug || flags.id;
+    if (!target) throw new Error('Podaj identyfikator lub slug zgłoszonego skilla, np. deertools skill review reject deer-technical-documentation --notes "Popraw opis formatu"');
+    const notes = flags.notes || flags.message || flags.m || '';
+    if (!notes || notes.trim().length === 0) {
+      throw new Error('Podaj uwagi i uzasadnienie dla autora (--notes "Treść uwag").');
+    }
+    out(`Odsyłam zgłoszenie do poprawek dla „${target}”...`);
+    const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(target);
+    const res = await skillsHub.decideReview({
+      slug: isUuid ? null : target,
+      reviewId: isUuid ? target : null,
+      approve: false,
+      notes,
+    });
+    if (!res.ok) {
+      throw new Error(`Błąd odsyłania (${res.status}): ${res.data?.error || 'Brak uprawnień lub błąd serwera'}`);
+    }
+    out(`\n\x1b[33m✓ Wysłano prośbę o poprawki (Request Changes) dla ${target}.\x1b[0m`);
+    out(`  Autor otrzymał uwagi w notyfikacji i statusie skilla: "${notes}".\n`);
+    return;
+  }
+
+  // 4. Listowanie kolejki review (Domyślne)
+  out(`Pobieram kolejkę Peer Review z DeerSkills Hub...`);
+  const res = await skillsHub.listReviews({
+    status: flags.status || (flags.all ? 'all' : 'pending'),
+  });
+
+  if (!res.ok) {
+    throw new Error(`Błąd pobierania listy review (${res.status}): ${res.data?.error || 'Brak dostępu'}`);
+  }
+
+  const items = Array.isArray(res.data) ? res.data : (res.data?.reviews || []);
+  if (items.length === 0) {
+    out('\n✓ Kolejka Peer Review jest pusta. Wszystkie zgłoszone skille zostały rozpatrzone.\n');
+    return;
+  }
+
+  out(`\n=== Kolejka zgłoszeń Skill Peer Review (${items.length}) ===\n`);
+  for (const r of items) {
+    const s = r.skills || {};
+    const slug = s.full_slug || s.slug || r.skill_id;
+    const author = r.requester_email || s.owner_email || s.owner_name || 'Nieznany';
+    const dateStr = new Date(r.created_at || Date.now()).toLocaleDateString('pl-PL');
+    const statusBadge = r.status === 'pending'
+      ? '\x1b[33m[⏳ Oczekuje na zatwierdzenie]\x1b[0m'
+      : r.status === 'approved'
+      ? '\x1b[32m[✓ Zatwierdzony]\x1b[0m'
+      : '\x1b[31m[✕ Wymaga poprawek]\x1b[0m';
+
+    out(`  • \x1b[1m${slug}\x1b[0m (v${r.version || s.latest_version}) ${statusBadge}`);
+    out(`    Autor:    ${author} (${dateStr})`);
+    if (s.summary) out(`    Opis:     ${s.summary.slice(0, 90)}...`);
+    if (r.review_notes) out(`    Uwagi:    \x1b[33m${r.review_notes}\x1b[0m`);
+    if (r.status === 'pending') {
+      out(`    Decyzja:  \x1b[36mdeertools skill review approve ${slug}\x1b[0m`);
+      out(`              \x1b[31mdeertools skill review reject ${slug} --notes "..."\x1b[0m`);
+    }
+    out('');
+  }
 }
 
 module.exports = {
   cmdSkillList,
   cmdSkillSearch,
   cmdSkillInstall,
+  cmdSkillSync,
   cmdSkillPush,
   cmdSkillCheck,
   cmdSkillUpdate,
   cmdSkillPromote,
   cmdSkillVersions,
   cmdSkillDiff,
+  cmdSkillReview,
+  cmdSkillShare,
   checkSkillUpdates,
   updateSkills,
 };