@deerdesign/deertools 1.2.13 → 1.2.21

package/README.md

@@ -185,18 +185,30 @@ deertools profile list
 deertools profile use staging
 
 # 12. AI Agent Skills (DeerSkills Hub):
-deertools skill list                         # Wyświetl skille (oficjalne globalne i Twoje)
-deertools skill search "kosztorys"           # Wyszukaj skille po nazwie, tagu lub opisie
-deertools skill install deer-kosztorys       # Zainstaluj skill w ~/.gemini/antigravity/skills lub .agents
+deertools skill list                         # Wyświetl listę skilli ze statusem zainstalowania w projekcie
+deertools skill sync                         # Jedna komenda: instaluje brakujące i aktualizuje obecne skille zespołu
+deertools skill install --all                # To samo co skill sync (pełna synchronizacja zespołu)
+deertools skill install deer-kosztorys       # Zainstaluj konkretny skill w ~/.gemini/antigravity/skills lub .agents
 deertools skill install deer-kosztorys --version 1.0.0
-deertools skill install all                  # Zainstaluj wszystkie oficjalne skille Deer Design
+deertools skill search "kosztorys"           # Wyszukaj skille po nazwie, tagu lub opisie
 deertools skill push ./my-skill              # Opublikuj nową wersję z automatycznym skanerem sekretów
-deertools skill push ./my-skill --bump minor # Automatyczne podbicie wersji SemVer
+deertools skill push ./my-skill --tags "wycena, kosztorys, marże" # Dodaj tagi przy publikacji
+deertools skill push ./my-skill --team architekci # Publikacja bezpośrednio do zespołu
+deertools skill share my-skill --team architekci    # Udostępnij skill dla wskazanego zespołu
+deertools skill share my-skill --private            # Cofnij udostępnienie (tylko dla autora)
 deertools skill update deer-kosztorys        # Zaktualizuj zainstalowany skill do najnowszej wersji
 deertools skill update                       # Zaktualizuj wszystkie zainstalowane skille
 deertools skill promote my-skill             # Zgłoś wniosek do admina o nominację do globalnego katalogu
 
-# 13. AI Agent MCP Registry & Configuration:
+# 13. Team Management (Konfiguracja Zespołów):
+deertools team list                          # Lista zespołów, liczba członków i skilli
+deertools team members architekci            # Członkowie i role w zespole architekci
+deertools team add architekci jan@deer.pl    # Dodaj członka do zespołu (rola member)
+deertools team add architekci ewa@deer.pl --role lead # Dodaj lidera zespołu
+deertools team remove architekci jan@deer.pl # Usuń członka z zespołu
+deertools team create "Projektanci Wnętrz" --slug projektanci # Utwórz nowy zespół
+
+# 14. AI Agent MCP Registry & Configuration:
 deertools mcp list                           # Lista dostępnych serwerów MCP w ekosystemie
 deertools mcp config                         # Wygeneruj konfigurację JSON dla Cursor, Claude, Antigravity
 deertools mcp install                        # Automatycznie dopisz konfigurację do narzędzi AI
@@ -233,10 +245,10 @@ deertools mcp install                        # Automatycznie dopisz konfiguracj
 
 **DeerSkills Hub** (`https://skills.deergroup.pl`) to centralna platforma dystrybucji, wersjonowania i zarządzania umiejętnościami agentów AI (Skills) oraz serwerami MCP w ekosystemie Deer Design:
 
-1. **Struktura i Uprawnienia**:
-   - **Oficjalne Skille (`global`)**: Zweryfikowane, wersjonowane semantycznie (`v1.0.0`) narzędzia firmowe, zarządzane wyłącznie przez Administratorów.
-   - **Skille Użytkowników (`user`)**: Każdy pracownik może tworzyć i wersjonować własne skille pod przestrzenią `@uzytkownik/nazwa-skilla`.
-   - **Widoczność**: `shared` (dostępne wewnątrz firmy dla zalogowanych) lub `private` (widoczne tylko dla autora).
+1. **Trzypoziomowa Struktura Uprawnień i Widoczności**:
+   - **Oficjalne Skille Firmowe (`global`)**: Zweryfikowane narzędzia firmowe, widoczne dla wszystkich pracowników w organizacji, instalowane domyślnie.
+   - **Skille Zespołowe (`team`)**: Dedykowane dla konkretnego zespołu (np. Architekci, Doradcy Klienta, Kosztorysy, Logistyka, IT-Dev). Widoczne i instalowalne **wyłącznie** przez członków danego zespołu. Zespoły i role są w pełni konfigurowalne przez `deertools team` oraz portal Web.
+   - **Prywatne Skille Użytkownika (`user`)**: Każdy pracownik publikuje pod własną przestrzenią `@uzytkownik/nazwa-skilla`. Są w 100% prywatne (niewidoczne dla innych), dopóki autor nie zdecyduje się ich udostępnić swojemu zespołowi (`deertools skill share --team <slug>`) lub zgłosić do publikacji globalnej (`deertools skill promote`).
 2. **Automatyczny Skaner Sekretów**:
    - Każde wywołanie `deertools skill push` automatycznie skanuje pliki skilla w poszukiwaniu niebezpiecznych tokenów (`deer_*_live_`, `ghp_`, `sk-`, `X-BLToken`, haseł).
    - Próba wysłania niezanominizowanych kluczy kończy się natychmiastową blokadą z kodem błędu i listą wykrytych linii.

package/package.json

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

package/src/agent-detector.js

@@ -3,6 +3,27 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
+const { execSync } = require('child_process');
+const readline = require('readline');
+const { readConfig, writeConfig } = require('./profiles');
+
+function isBinaryInPath(cmd) {
+  try {
+    const check = process.platform === 'win32' ? `where ${cmd} 2>nul` : `which ${cmd} 2>/dev/null`;
+    execSync(check, { stdio: 'ignore', timeout: 800 });
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+function isAppInstalled(appName) {
+  if (process.platform === 'darwin') {
+    return fs.existsSync(`/Applications/${appName}.app`) || fs.existsSync(path.join(os.homedir(), `Applications/${appName}.app`));
+  }
+  return false;
+}
+
 /**
  * Rejestr obsługiwanych platform agentów AI.
  * Obsługuje: Google Antigravity / Gemini, Claude Code, OpenAI Codex, Hermes AI,
@@ -19,35 +40,35 @@ const KNOWN_AGENTS = [
   {
     id: 'claude',
     name: 'Claude Code',
-    detect: (home) => fs.existsSync(path.join(home, '.claude')),
+    detect: (home) => fs.existsSync(path.join(home, '.claude')) || isBinaryInPath('claude'),
     getTarget: (home) => path.join(home, '.claude', 'skills'),
     format: 'skill_md',
   },
   {
     id: 'codex',
     name: 'OpenAI Codex',
-    detect: (home) => fs.existsSync(path.join(home, '.codex')),
+    detect: (home) => fs.existsSync(path.join(home, '.codex')) || isBinaryInPath('codex'),
     getTarget: (home) => path.join(home, '.codex', 'skills'),
     format: 'skill_md',
   },
   {
     id: 'hermes',
     name: 'Hermes AI',
-    detect: (home) => fs.existsSync(path.join(home, '.hermes')) || fs.existsSync(path.join(home, '.config', 'hermes')) || Boolean(process.env.HERMES_HOME),
+    detect: (home) => fs.existsSync(path.join(home, '.hermes')) || fs.existsSync(path.join(home, '.config', 'hermes')) || Boolean(process.env.HERMES_HOME) || isBinaryInPath('hermes'),
     getTarget: (home) => process.env.HERMES_SKILLS_DIR || path.join(home, '.hermes', 'skills'),
     format: 'skill_md',
   },
   {
     id: 'cursor',
     name: 'Cursor IDE',
-    detect: (home, cwd) => fs.existsSync(path.join(cwd, '.cursor')) || fs.existsSync(path.join(home, '.cursor')),
+    detect: (home, cwd) => fs.existsSync(path.join(cwd, '.cursor')) || fs.existsSync(path.join(home, '.cursor')) || isAppInstalled('Cursor'),
     getTarget: (home, cwd) => fs.existsSync(path.join(cwd, '.cursor')) ? path.join(cwd, '.cursor', 'rules') : path.join(home, '.cursor', 'rules'),
     format: 'cursor_mdc',
   },
   {
     id: 'windsurf',
     name: 'Windsurf / Codeium',
-    detect: (home, cwd) => fs.existsSync(path.join(cwd, '.windsurfrules')) || fs.existsSync(path.join(cwd, '.windsurf')) || fs.existsSync(path.join(home, '.codeium')),
+    detect: (home, cwd) => fs.existsSync(path.join(cwd, '.windsurfrules')) || fs.existsSync(path.join(cwd, '.windsurf')) || fs.existsSync(path.join(home, '.codeium')) || isAppInstalled('Windsurf'),
     getTarget: (home, cwd) => path.join(cwd, '.windsurf', 'rules'),
     format: 'skill_md',
   },
@@ -61,7 +82,40 @@ const KNOWN_AGENTS = [
 ];
 
 /**
- * Wykrywa zainstalowane środowiska agentów lub filtruje według flagi --agent.
+ * Zwraca listę skonfigurowanych agentów użytkownika na tym PC.
+ */
+function getSelectedAgents() {
+  if (process.env.DEERTOOLS_AGENTS) {
+    const fromEnv = process.env.DEERTOOLS_AGENTS.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean);
+    if (fromEnv.length > 0) return fromEnv;
+  }
+  const cfg = readConfig();
+  if (cfg.selectedAgents && Array.isArray(cfg.selectedAgents) && cfg.selectedAgents.length > 0) {
+    return cfg.selectedAgents.map((s) => String(s).trim().toLowerCase());
+  }
+  return null;
+}
+
+/**
+ * Zapisuje listę wybranych agentów użytkownika w konfiguracji ~/.deertools/config.json.
+ */
+function setSelectedAgents(agentIds) {
+  const cfg = readConfig();
+  cfg.selectedAgents = agentIds.map((s) => String(s).trim().toLowerCase());
+  writeConfig(cfg);
+}
+
+/**
+ * Czyści zapisaną listę agentów (przywraca auto-detekcję wszystkich obecnych na PC).
+ */
+function clearSelectedAgents() {
+  const cfg = readConfig();
+  delete cfg.selectedAgents;
+  writeConfig(cfg);
+}
+
+/**
+ * Wykrywa zainstalowane środowiska agentów lub filtruje według flagi --agent / konfiguracji.
  */
 function detectAgents(options = {}) {
   const home = os.homedir();
@@ -77,7 +131,7 @@ function detectAgents(options = {}) {
     }];
   }
 
-  // Wymuszenie instalacji do WSZYSTKICH obsługiwanych platform (--all-agents)
+  // Wymuszenie instalacji do WSZYSTKICH znanych platform (--all-agents)
   if (options['all-agents']) {
     return KNOWN_AGENTS.map((spec) => ({
       id: spec.id,
@@ -87,21 +141,35 @@ function detectAgents(options = {}) {
     }));
   }
 
-  // Wskazanie konkretnego agenta (--agent claude / --agent codex / --agent hermes / etc.)
+  // Wskazanie konkretnego agenta lub listy po przecinku (--agent claude,antigravity)
   if (options.agent && options.agent !== 'all' && options.agent !== 'auto') {
-    const requested = options.agent.toLowerCase().trim();
-    const spec = KNOWN_AGENTS.find((a) => a.id === requested);
-    if (spec) {
-      return [{
+    const requested = options.agent.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean);
+    const matched = KNOWN_AGENTS.filter((spec) => requested.includes(spec.id));
+    if (matched.length > 0) {
+      return matched.map((spec) => ({
+        id: spec.id,
+        name: spec.name,
+        targetDir: spec.getTarget(home, cwd),
+        format: spec.format,
+      }));
+    }
+  }
+
+  // Jeśli użytkownik ma zapisaną konfigurację wybranych agentów na tym PC:
+  const configured = getSelectedAgents();
+  if (configured && configured.length > 0 && !options['ignore-selected']) {
+    const matched = KNOWN_AGENTS.filter((spec) => configured.includes(spec.id));
+    if (matched.length > 0) {
+      return matched.map((spec) => ({
         id: spec.id,
         name: spec.name,
         targetDir: spec.getTarget(home, cwd),
         format: spec.format,
-      }];
+      }));
     }
   }
 
-  // Automatyczne wykrywanie obecnych agentów
+  // Automatyczne wykrywanie obecnych agentów na PC
   const matched = [];
   for (const spec of KNOWN_AGENTS) {
     try {
@@ -157,4 +225,48 @@ function installSkillContent(agent, skillName, rawMarkdown) {
   return filePath;
 }
 
-module.exports = { KNOWN_AGENTS, detectAgents, installSkillContent };
+/**
+ * Interaktywny prompt pytający użytkownika o wybór platform agentów w terminalu.
+ */
+async function promptSelectAgents(availableAgents) {
+  if (!process.stdin.isTTY) return availableAgents;
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    process.stdout.write(`\nWykryto platformy agentów AI na tym komputerze:\n`);
+    availableAgents.forEach((a, i) => {
+      process.stdout.write(`  [${i + 1}] ${a.name} (${a.id})\n`);
+    });
+    process.stdout.write(`\nWybierz platformy (np. 1, 3 lub 'all') [domyślnie: wszystkie wykryte]: `);
+
+    rl.question('', (answer) => {
+      rl.close();
+      const trimmed = (answer || '').trim().toLowerCase();
+      if (!trimmed || trimmed === 'all') {
+        resolve(availableAgents);
+        return;
+      }
+      const parts = trimmed.split(/[\s,]+/).map((p) => parseInt(p, 10)).filter((n) => !isNaN(n) && n >= 1 && n <= availableAgents.length);
+      if (parts.length === 0) {
+        resolve(availableAgents);
+        return;
+      }
+      const selected = parts.map((n) => availableAgents[n - 1]);
+      resolve(selected);
+    });
+  });
+}
+
+module.exports = {
+  KNOWN_AGENTS,
+  detectAgents,
+  installSkillContent,
+  getSelectedAgents,
+  setSelectedAgents,
+  clearSelectedAgents,
+  promptSelectAgents,
+  isBinaryInPath,
+};

package/src/cli.js

@@ -32,6 +32,9 @@ async function main(argv) {
   const table = {
     login: c.cmdLogin, logout: c.cmdLogout, whoami: c.cmdWhoami, docs: c.cmdDocs,
     endpoints: c.cmdEndpoints, api: c.cmdApi, estimate: c.cmdEstimate, skill: c.cmdSkill,
+    sync: (pos, flags) => c.cmdSkill(['sync', ...pos], flags),
+    agent: c.cmdAgent, agents: c.cmdAgent,
+    team: c.cmdTeam, teams: c.cmdTeam,
     mcp: c.cmdMcp, doctor: c.cmdDoctor, audit: c.cmdAudit, profile: c.cmdProfile,
     completion: c.cmdCompletion, catalog: c.cmdCatalog, deliveries: c.cmdDeliveries,
     supplier: c.cmdSupplier, rendermind: c.cmdRendermind, baselinker: c.cmdBaseLinker,

package/src/commands.js

@@ -379,6 +379,9 @@ async function cmdSkill(pos, flags) {
   if (sub === 'bundle') {
     return cmdSkillBundle(pos[1], flags);
   }
+  if (sub === 'sync') {
+    return skillCommands.cmdSkillSync(flags, out, err);
+  }
   if (sub === 'list') {
     return skillCommands.cmdSkillList(flags, out, err);
   }
@@ -403,10 +406,27 @@ async function cmdSkill(pos, flags) {
   if (sub === 'promote') {
     return skillCommands.cmdSkillPromote(pos[1], flags, out, err);
   }
+  if (sub === 'review' || sub === 'reviews') {
+    return skillCommands.cmdSkillReview(pos.slice(1), flags, out, err);
+  }
+  if (sub === 'approve') {
+    return skillCommands.cmdSkillReview(['approve', ...pos.slice(1)], flags, out, err);
+  }
+  if (sub === 'reject') {
+    return skillCommands.cmdSkillReview(['reject', ...pos.slice(1)], flags, out, err);
+  }
+  if (sub === 'share') {
+    return skillCommands.cmdSkillShare(pos[1], flags, out, err);
+  }
+  if (sub === 'team' || sub === 'teams') {
+    const { cmdTeam: runTeam } = require('./team-commands');
+    return runTeam(pos.slice(1), flags, out, err);
+  }
   if (sub === 'install') {
-    return skillCommands.cmdSkillInstall(pos[1], flags, out, err);
+    const target = pos[1] || (flags.all ? '--all' : null);
+    return skillCommands.cmdSkillInstall(target, 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 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);
+  fail('Użycie:\n  deertools skill login [token]\n  deertools skill sync [--force]\n  deertools skill bundle <architekci|kosztorysy|logistyka|sprzedaz|it>\n  deertools skill list [--tag <tag>]\n  deertools skill search <fraza>\n  deertools skill install [--all|<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] [--team <zespół>] [--own|--global] [--bump patch|minor|major]\n  deertools skill share <slug> --team <zespół>\n  deertools skill review [list|approve|reject|submit]\n  deertools skill promote <slug>', 2);
 }
 
 
@@ -508,6 +528,96 @@ async function cmdMcp(pos, flags) {
   fail('Użycie: deertools mcp [config|install|serve] [produkt|all] [--json]', 2);
 }
 
+async function cmdAgent(pos, flags) {
+  const {
+    KNOWN_AGENTS,
+    detectAgents,
+    getSelectedAgents,
+    setSelectedAgents,
+    clearSelectedAgents,
+    promptSelectAgents,
+  } = require('./agent-detector');
+  const action = pos[0] || 'list';
+
+  if (action === 'list') {
+    const selected = getSelectedAgents();
+    const detected = detectAgents({ 'ignore-selected': true });
+    const detectedIds = new Set(detected.map((a) => a.id));
+
+    out(`\n=== Platformy Agentów AI (DeerTools) ===\n`);
+    for (const a of KNOWN_AGENTS) {
+      const isDetected = detectedIds.has(a.id);
+      const isActive = selected ? selected.includes(a.id) : isDetected;
+
+      let statusBadge = '\x1b[90m[○ Niewykryty na PC]\x1b[0m';
+      if (isDetected) statusBadge = '\x1b[32m[✓ Wykryty na PC]\x1b[0m';
+
+      let activeBadge = '';
+      if (isActive) {
+        activeBadge = ' \x1b[36m(AKTYWNY DLA SKILLI)\x1b[0m';
+      }
+
+      out(`  • ${a.id.padEnd(16)} ${(a.name).padEnd(32)} ${statusBadge}${activeBadge}`);
+      out(`    Ścieżka: ${a.getTarget(os.homedir(), process.cwd())}`);
+      out('');
+    }
+
+    out('─'.repeat(72));
+    if (selected && selected.length > 0) {
+      out(`📌 Wybrane platformy na tym PC: \x1b[36m${selected.join(', ')}\x1b[0m (zapisane w ~/.deertools/config.json)`);
+      out(`   Skille instalują się tylko u wybranych agentów.`);
+      out(`   Aby przywrócić auto-wykrywanie wszystkich: \x1b[33mdeertools agent reset\x1b[0m`);
+    } else {
+      out(`⚡ Tryb: \x1b[32mAutomatyczne wykrywanie wszystkich platform obecnych na komputerze\x1b[0m`);
+      out(`   Aby ograniczyć synchronizację do wybranych agentów:`);
+      out(`   \x1b[36mdeertools agent select antigravity,cursor\x1b[0m`);
+    }
+    out('─'.repeat(72) + '\n');
+    return;
+  }
+
+  if (action === 'select' || action === 'set') {
+    let targets = pos.slice(1).join(',').split(',').map((s) => s.trim().toLowerCase()).filter(Boolean);
+    if (targets.length === 0) {
+      const detected = detectAgents({ 'ignore-selected': true });
+      const picked = await promptSelectAgents(detected);
+      targets = picked.map((a) => a.id);
+    }
+
+    const validIds = KNOWN_AGENTS.map((a) => a.id);
+    const validTargets = targets.filter((id) => validIds.includes(id));
+
+    if (validTargets.length === 0) {
+      fail(`Błąd: Podaj poprawne identyfikatory agentów: ${validIds.join(', ')}`, 2);
+    }
+
+    setSelectedAgents(validTargets);
+    out(`✓ Zapisano aktywnych agentów na tym komputerze: \x1b[36m${validTargets.join(', ')}\x1b[0m`);
+    out(`Od teraz deertools skill sync i skill install instalują skille tylko dla tych platform.`);
+    out(`Aby przywrócić instalację u wszystkich wykrytych: deertools agent reset\n`);
+    return;
+  }
+
+  if (action === 'reset' || action === 'clear') {
+    clearSelectedAgents();
+    out(`✓ Zresetowano konfigurację agentów. Przywrócono automatyczne wykrywanie obecnych na PC.\n`);
+    return;
+  }
+
+  if (action === 'current') {
+    const active = detectAgents({});
+    out(active.map((a) => a.id).join(','));
+    return;
+  }
+
+  fail(`Nieznana podkomenda „agent ${action}”. Użyj: deertools agent [list|select <agenty>|reset|current]`, 2);
+}
+
+async function cmdTeam(pos, flags) {
+  const { cmdTeam: runTeam } = require('./team-commands');
+  return runTeam(pos, flags, out, err);
+}
+
 const { cmdDoctor } = require('./doctor');
 const { cmdAudit } = require('./audit');
 const { cmdProfile } = require('./profiles');
@@ -544,12 +654,16 @@ BaseLinker MCP Proxy & Hub:
   deertools baselinker catalog <search|get>             Operacje katalogowe z poziomu terminala.
 
 Integracje MCP i Agenci AI (DeerSkills Hub):
-  deertools skill list [--tag <tag>]                    Przegląda skille globalne i użytkownika w DeerSkills Hub.
+  deertools agent [list|select <agenty>|reset]          Wykrywanie i konfiguracja platform agentów AI na PC.
+  deertools skill list [--tag <tag>]                    Przegląda skille w Hubie wraz ze statusem zainstalowania.
+  deertools skill sync [--agent <id>|-i|--force]        Instaluje brakujące i aktualizuje obecne skille zespołu.
+  deertools skill install [--all|<slug[@wersja]>]       Instaluje wszystkie skille (--all) lub wskazany skill.
   deertools skill search <fraza>                        Wyszukuje umiejętności po słowach kluczowych.
-  deertools skill install <slug[@wersja]>               Instaluje skill w ~/.gemini/antigravity/skills lub .agents.
   deertools skill versions <slug>                       Historia wydań z changelogami z commitów i datami.
   deertools skill diff <slug> [wersjaA] [wersjaB]       Porównanie zmian w plikach paczki i treści SKILL.md.
-  deertools skill push [katalog] [--bump patch|minor]   Publikuje nową wersję z automatycznym skanerem sekretów.
+  deertools skill push [katalog] [--team <zespół>]      Publikuje do własnej przestrzeni, zespołu lub globalnie.
+  deertools skill share <slug> --team <zespół>          Udostępnia skill prywatny wskazanemu zespołowi.
+  deertools skill review [list|approve|reject|submit]   Zarządzanie procesem Peer Review i weryfikacją skilli zespołu.
   deertools skill update [slug]                         Aktualizuje zainstalowane skille do najnowszej wersji.
   deertools skill promote <slug>                        Zgłasza nominację skilla do oficjalnego katalogu globalnego.
   deertools mcp list                                    Lista dostępnych serwerów MCP w chmurze.
@@ -560,19 +674,26 @@ Integracje MCP i Agenci AI (DeerSkills Hub):
   deertools endpoints <produkt> [--json]                Lista endpointów REST z openapi.json.
   deertools api <produkt> <METODA> </ścieżka>           Wywołuje bezpośrednio API produktu.
 
+Zarządzanie zespołami (DeerSkills Hub Teams):
+  deertools team [list]                                 Przegląda listę zespołów, liczbę członków i przypisanych skilli.
+  deertools team members [zespół]                       Lista członków zespołów i ich ról (Lider / Członek).
+  deertools team add <zespół> <email> [--role lead]     Dodaje lub aktualizuje rolę pracownika w zespole.
+  deertools team remove <zespół> <email>                Usuwa pracownika ze wskazanego zespołu.
+  deertools team create <nazwa> [--slug <s>] [--desc]   Tworzy nowy zespół w organizacji Deer Design.
+
 Narzędzia systemowe:
   deertools update                                      Sprawdza i podpowiada aktualizację CLI.
   deertools doctor [--json]                             Pełna diagnostyka połączeń, portów i kluczy.
   deertools audit [--limit 25] [--clear] [--json]       Historia operacji i wywołań API.
   deertools completion [install|zsh|bash]               Autouzupełnianie w powłoce po wciśnięciu Tab.
 
-Zmienne środowiskowe: DEERTOOLS_<PRODUKT>_KEY, BASELINKER_TOKEN, DEERTOOLS_HOME, DEERTOOLS_PROFILE.
+Zmienne środowiskowe: DEERTOOLS_<PRODUKT>_KEY, BASELINKER_TOKEN, DEERTOOLS_HOME, DEERTOOLS_PROFILE, DEERTOOLS_AGENTS.
 `;
 
 module.exports = {
   cmdLogin, cmdLogout, cmdWhoami, cmdDocs, cmdEndpoints, cmdApi, cmdEstimate, cmdSkill, cmdMcp,
   cmdDoctor, cmdAudit, cmdProfile, cmdCompletion, cmdCatalog, cmdDeliveries, cmdSupplier, cmdRendermind,
-  cmdBaseLinker,
+  cmdBaseLinker, cmdAgent, cmdTeam,
   HELP, parseQuery,
 };
 

package/src/mcp-stdio.js

@@ -4,6 +4,7 @@ const credentials = require('./credentials');
 const { ALL_PRODUCTS, getProduct } = require('./registry');
 const { apiRequest } = require('./http');
 const { checkSkillUpdates, updateSkills } = require('./skill-commands');
+const skillsHub = require('./skills-hub');
 
 const PROTOCOL_VERSION = '2024-11-05';
 const SERVER_INFO = { name: 'deertools-stdio-bridge', version: '1.0.5' };
@@ -113,6 +114,40 @@ async function cmdMcpServe(pos, flags) {
             required: ['confirmed'],
           },
         },
+        {
+          name: 'deer_list_skill_reviews',
+          description: 'Pobiera kolejkę zgłoszeń skilli do Peer Review z DeerSkills Hub (zgłoszenia oczekujące, zatwierdzone lub odesłane do poprawek).',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              status: { type: 'string', enum: ['pending', 'approved', 'changes_requested', 'all'], description: 'Status zgłoszenia (domyślnie pending - oczekujące)' },
+            },
+          },
+        },
+        {
+          name: 'deer_decide_skill_review',
+          description: 'Rozpatrzenie zgłoszonego skilla w Peer Review (zatwierdzenie do katalogu globalnego lub odesłanie do poprawek z uwagami) przez leada/admina.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              slug: { type: 'string', description: 'Identyfikator (slug) zgłoszonego skilla, np. deer-technical-documentation' },
+              approve: { type: 'boolean', description: 'true = zatwierdź (Approve) i przenieś do katalogu globalnego, false = odeślij do poprawek (Request Changes)' },
+              notes: { type: 'string', description: 'Uwagi i wytyczne dla autora (obowiązkowe przy odrzuceniu/poprawkach)' },
+            },
+            required: ['slug', 'approve'],
+          },
+        },
+        {
+          name: 'deer_submit_skill_review',
+          description: 'Zgłoszenie własnego opublikowanego skilla do weryfikacji zespołu / Peer Review w DeerSkills Hub.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              slug: { type: 'string', description: 'Identyfikator (slug) skilla do zgłoszenia, np. @mariusz.szostak/moj-skill' },
+            },
+            required: ['slug'],
+          },
+        },
       ];
 
       send({ jsonrpc: '2.0', id, result: { tools } });
@@ -269,6 +304,77 @@ async function cmdMcpServe(pos, flags) {
           return;
         }
 
+        if (toolName === 'deer_list_skill_reviews') {
+          const res = await skillsHub.listReviews({ status: args.status || 'pending' });
+          if (!res.ok) {
+            send({ jsonrpc: '2.0', id, error: { code: -32000, message: res.data?.error || `Błąd pobierania (${res.status})` } });
+            return;
+          }
+          send({
+            jsonrpc: '2.0',
+            id,
+            result: { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] },
+          });
+          return;
+        }
+
+        if (toolName === 'deer_decide_skill_review') {
+          const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(args.slug);
+          const res = await skillsHub.decideReview({
+            slug: isUuid ? null : args.slug,
+            reviewId: isUuid ? args.slug : null,
+            approve: Boolean(args.approve),
+            notes: args.notes || '',
+          });
+          if (!res.ok) {
+            send({ jsonrpc: '2.0', id, error: { code: -32000, message: res.data?.error || `Błąd rozpatrywania (${res.status})` } });
+            return;
+          }
+          send({
+            jsonrpc: '2.0',
+            id,
+            result: {
+              content: [{
+                type: 'text',
+                text: JSON.stringify({
+                  success: true,
+                  decision: args.approve ? 'approved' : 'changes_requested',
+                  skill: res.data?.skill || res.data,
+                  notes: args.notes || null,
+                  message: args.approve
+                    ? `Skill został pomyślnie zatwierdzony i opublikowany w katalogu globalnym zespołu.`
+                    : `Zgłoszenie zostało odesłane do poprawek z uwagami dla autora.`,
+                }, null, 2),
+              }],
+            },
+          });
+          return;
+        }
+
+        if (toolName === 'deer_submit_skill_review') {
+          const res = await skillsHub.submitReview(args.slug);
+          if (!res.ok) {
+            send({ jsonrpc: '2.0', id, error: { code: -32000, message: res.data?.error || `Błąd zgłaszania (${res.status})` } });
+            return;
+          }
+          send({
+            jsonrpc: '2.0',
+            id,
+            result: {
+              content: [{
+                type: 'text',
+                text: JSON.stringify({
+                  success: true,
+                  status: 'in_review',
+                  skill: args.slug,
+                  message: `Skill ${args.slug} został pomyślnie zgłoszony do Peer Review zespołu.`,
+                }, 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 } });