@deerdesign/deertools 1.2.25 → 1.2.27

package/src/skill-commands.js

@@ -92,6 +92,82 @@ function readSkillVersion(filePath, lock, skill) {
   return '1.0.0';
 }
 
+/**
+ * Skanuje lokalne katalogi w poszukiwaniu skilli na dysku.
+ * Zwraca mapę slug -> { slug, version, dir, filePath, summary }.
+ */
+function scanLocalSkills(cwd = process.cwd(), agents = [], hubSlugs = null) {
+  const localSkills = new Map();
+
+  function inspectDir(skillDir, isAgentDir = false) {
+    const skillMd = path.join(skillDir, 'SKILL.md');
+    if (!fs.existsSync(skillMd)) return;
+    try {
+      const content = fs.readFileSync(skillMd, 'utf8');
+      let slug = path.basename(skillDir);
+      let version = '1.0.0';
+      let summary = '';
+      if (content.startsWith('---')) {
+        const parts = content.split('---', 2);
+        if (parts.length >= 2) {
+          const nameMatch = parts[1].match(/^name:\s*(.+)$/m);
+          if (nameMatch) slug = nameMatch[1].trim();
+          const verMatch = parts[1].match(/^version:\s*['"]?([0-9]+\.[0-9]+(\.[0-9]+)?(-[a-zA-Z0-9.]+)?)/im);
+          if (verMatch) version = verMatch[1].trim();
+          const descMatch = parts[1].match(/^description:\s*(.+)$/m);
+          if (descMatch) summary = descMatch[1].trim();
+        }
+      }
+
+      // Jeśli skanujemy katalog zewnętrznego agenta (~/.gemini/...): bierzemy tylko skille Deer Design lub znane w Hubie
+      if (isAgentDir) {
+        const isDeer = slug.startsWith('deer') || slug.startsWith('rendermind') || slug.startsWith('@');
+        const isKnown = hubSlugs && (hubSlugs.has(slug) || hubSlugs.has(slug.replace(/^@[^/]+\//, '')));
+        if (!isDeer && !isKnown) return;
+      }
+
+      if (!localSkills.has(slug)) {
+        localSkills.set(slug, {
+          slug,
+          version,
+          dir: skillDir,
+          filePath: skillMd,
+          summary,
+        });
+      }
+    } catch (_) {}
+  }
+
+  // 1. Sprawdź .agents/skills w bieżącym projekcie
+  const projectAgentsSkills = path.join(cwd, '.agents', 'skills');
+  if (fs.existsSync(projectAgentsSkills)) {
+    try {
+      const entries = fs.readdirSync(projectAgentsSkills, { withFileTypes: true });
+      for (const ent of entries) {
+        if (ent.isDirectory() && !ent.name.startsWith('.')) {
+          inspectDir(path.join(projectAgentsSkills, ent.name), false);
+        }
+      }
+    } catch (_) {}
+  }
+
+  // 2. Sprawdź katalogi wykrytych agentów (tylko skille powiązane z Hubem lub Deer Design)
+  for (const agent of agents) {
+    if (agent.targetDir && fs.existsSync(agent.targetDir)) {
+      try {
+        const entries = fs.readdirSync(agent.targetDir, { withFileTypes: true });
+        for (const ent of entries) {
+          if (ent.isDirectory() && !ent.name.startsWith('.')) {
+            inspectDir(path.join(agent.targetDir, ent.name), true);
+          }
+        }
+      } catch (_) {}
+    }
+  }
+
+  return localSkills;
+}
+
 /**
  * Bada stan instalacji i wersję skilla u wszystkich zadanych agentów.
  */
@@ -101,6 +177,7 @@ function inspectSkillForAgents(agents, skill, lock) {
   let upToDateCount = 0;
   let outdatedCount = 0;
   let missingCount = 0;
+  let aheadCount = 0;
 
   for (const agent of agents) {
     const filePath = findSkillFileForAgent(agent, skill);
@@ -122,7 +199,7 @@ function inspectSkillForAgents(agents, skill, lock) {
     const installedVer = readSkillVersion(filePath, lock, skill);
     const cmp = compareSemver(installedVer, skill.latest_version);
 
-    if (cmp >= 0) {
+    if (cmp === 0) {
       agentStatuses[agent.id] = {
         agentId: agent.id,
         agentName: agent.name,
@@ -133,6 +210,19 @@ function inspectSkillForAgents(agents, skill, lock) {
         badge: `\x1b[32m[✓ ${agent.id}: v${installedVer}]\x1b[0m`,
       };
       upToDateCount += 1;
+    } else if (cmp > 0) {
+      agentStatuses[agent.id] = {
+        agentId: agent.id,
+        agentName: agent.name,
+        installed: true,
+        version: installedVer,
+        status: 'ahead',
+        hub_version: skill.latest_version,
+        filePath,
+        badge: `\x1b[35m[★ ${agent.id}: v${installedVer} > Hub v${skill.latest_version}]\x1b[0m`,
+      };
+      upToDateCount += 1;
+      aheadCount += 1;
     } else {
       agentStatuses[agent.id] = {
         agentId: agent.id,
@@ -152,7 +242,10 @@ function inspectSkillForAgents(agents, skill, lock) {
   let overallBadge = '\x1b[90m[○ Niezainstalowany]\x1b[0m';
 
   if (installedCount > 0) {
-    if (installedCount === agents.length && outdatedCount === 0) {
+    if (aheadCount > 0) {
+      overallStatus = 'ahead';
+      overallBadge = `\x1b[35m[★ Nowszy lokalnie (${aheadCount})]\x1b[0m`;
+    } else if (installedCount === agents.length && outdatedCount === 0) {
       overallStatus = 'up_to_date';
       overallBadge = `\x1b[32m[✓ Aktualny (${installedCount}/${agents.length})]\x1b[0m`;
     } else if (outdatedCount > 0) {
@@ -170,6 +263,7 @@ function inspectSkillForAgents(agents, skill, lock) {
     upToDateCount,
     outdatedCount,
     missingCount,
+    aheadCount,
     overallStatus,
     overallBadge,
   };
@@ -279,9 +373,17 @@ async function cmdSkillList(flags, out, err) {
     out(`   • ${(a.name + ' (' + a.id + '):').padEnd(36)} ${badgeText}`);
   }
 
+  const anyAhead = items.some((s) => {
+    const insp = inspectSkillForAgents(agents, s, lock);
+    return insp.overallStatus === 'ahead';
+  });
+
   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 if (anyAhead) {
+    out(`\n💡 Wykryto skille nowsze lokalnie niż w Hubie:`);
+    out(`   \x1b[35mdeertools sync --push\x1b[0m   (aby wypchnąć je do DeerSkills Hub)`);
   } else {
     out(`\n✓ Wszystkie skille zespołu (${items.length}) są zainstalowane i aktualne u wszystkich wykrytych agentów.`);
   }
@@ -327,6 +429,18 @@ async function installSingleSkill(slug, requestedVersion, flags, out, err, { sil
 
   let count = 0;
   for (const agent of agents) {
+    // Bezpieczeństwo: jeśli lokalna wersja na dysku jest nowsza niż w Hubie, chroń przed nadpisaniem (wymagaj --force)
+    const existingFile = findSkillFileForAgent(agent, skill);
+    if (existingFile && !flags.force && !requestedVersion) {
+      const currentDiskVer = readSkillVersion(existingFile, readLock(flags.dir), skill);
+      if (currentDiskVer && compareSemver(currentDiskVer, versionData.version) > 0) {
+        if (!silentSummary) {
+          out(`  \x1b[35m★ [${agent.id}]\x1b[0m Pominięto instalację ${skill.slug}: wersja na dysku (v${currentDiskVer}) jest nowsza niż w Hubie (v${versionData.version}). Użyj --force aby nadpisać.`);
+        }
+        continue;
+      }
+    }
+
     try {
       const dest = installSkillContent(agent, skill.slug, versionData.skill_md_content);
       if (!silentSummary) {
@@ -372,8 +486,10 @@ async function installSingleSkill(slug, requestedVersion, flags, out, err, { sil
 
 /**
  * Instaluje lub synchronizuje wszystkie skille zespołu z DeerSkills Hub.
+ * Wspiera flagę --push (lub --auto-push): automatycznie publikuje nowsze lokalne wersje do Hubu.
  */
 async function cmdSkillSync(flags, out, err) {
+  const shouldPush = Boolean(flags.push || flags['auto-push']);
   out('Pobieram pełną listę skilli zespołu z DeerSkills Hub...');
   const res = await skillsHub.listSkills({ limit: 100 });
   if (!res.ok) {
@@ -399,14 +515,20 @@ async function cmdSkillSync(flags, out, err) {
     return;
   }
 
-  const lock = readLock(flags.dir);
+  const cwd = flags.dir || process.cwd();
+  const lock = readLock(cwd);
+  const hubSlugs = new Set(items.flatMap((s) => [s.slug, s.full_slug, s.slug.replace(/^@[^/]+\//, '')]));
+  const localSkills = scanLocalSkills(cwd, agents, hubSlugs);
+
   out(`Platformy docelowe: \x1b[36m${agents.map((a) => a.name || a.id).join(', ')}\x1b[0m`);
-  out(`Rozpoczynam synchronizację ${items.length} skilli zespołu...\n`);
+  out(`Rozpoczynam synchronizację ${items.length} skilli zespołu...${shouldPush ? ' \x1b[35m[Tryb dwukierunkowy: --push]\x1b[0m' : ''}\n`);
 
   let installedCount = 0;
   let updatedCount = 0;
   let unchangedCount = 0;
   let failedCount = 0;
+  let pushedCount = 0;
+  const aheadSkills = [];
 
   for (const s of items) {
     const slug = s.slug;
@@ -415,16 +537,74 @@ async function cmdSkillSync(flags, out, err) {
     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]`);
+    // Sprawdź wersję lokalną na dysku u agentów lub w .agents/skills
+    const localSkill = localSkills.get(slug) || localSkills.get(fullSlug) || localSkills.get(slug.replace(/^@[^/]+\//, ''));
+    let localDiskVer = localSkill?.version || null;
+
+    if (!localDiskVer) {
+      for (const agent of agents) {
+        const fp = findSkillFileForAgent(agent, s);
+        if (fp) {
+          const v = readSkillVersion(fp, lock, s);
+          if (v) { localDiskVer = v; break; }
+        }
+      }
+    }
+
+    const effectiveLocalVer = localDiskVer || currentVer;
+    const cmpLocalToHub = effectiveLocalVer ? compareSemver(effectiveLocalVer, latestVer) : -1;
+
+    // 1. Ochrona bezpieczeństwa: Lokalna wersja jest nowsza niż w Hubie (AHEAD)
+    if (cmpLocalToHub > 0) {
+      const pushDir = localSkill?.dir || (localSkill?.filePath ? path.dirname(localSkill.filePath) : null) || path.join(cwd, '.agents', 'skills', slug);
+      aheadSkills.push({
+        slug: s.full_slug || s.slug,
+        localVersion: effectiveLocalVer,
+        hubVersion: latestVer,
+        dir: pushDir,
+      });
+
+      if (shouldPush) {
+        try {
+          out(`  \x1b[35m↑ PUSH\x1b[0m ${s.full_slug.padEnd(36)} v${effectiveLocalVer} → Hub (wypychanie lokalnej nowości)...`);
+          const pushRes = await skillsHub.pushSkill(pushDir, {
+            version: effectiveLocalVer,
+            changelog: flags.changelog || `Synchronizacja dwukierunkowa: wypchnięto lokalną wersję v${effectiveLocalVer}`,
+          });
+          if (pushRes.ok) {
+            out(`  \x1b[32m✓ PUSHED\x1b[0m ${s.full_slug.padEnd(34)} v${effectiveLocalVer} opublikowano w DeerSkills Hub.`);
+            pushedCount += 1;
+            lock.skills[slug] = {
+              fullSlug: s.full_slug,
+              version: effectiveLocalVer,
+              installedAt: new Date().toISOString(),
+            };
+            writeLock(lock, cwd);
+          } else {
+            out(`  \x1b[31m✗ PUSH BŁĄD\x1b[0m ${s.full_slug}: ${pushRes.data?.error || 'Błąd publikacji'}`);
+          }
+        } catch (pe) {
+          out(`  \x1b[31m✗ PUSH BŁĄD\x1b[0m ${s.full_slug}: ${pe.message}`);
+        }
+      } else {
+        out(`  \x1b[35m★\x1b[0m ${s.full_slug.padEnd(38)} v${effectiveLocalVer.padEnd(8)} [Lokalnie nowszy niż w Hubie (Hub: v${latestVer})]`);
+      }
+      unchangedCount += 1;
+      continue;
+    }
+
+    // 2. Wersje identyczne - aktualny
+    if (effectiveLocalVer && cmpLocalToHub === 0 && !flags.force) {
+      out(`  \x1b[32m✓\x1b[0m ${s.full_slug.padEnd(38)} v${effectiveLocalVer.padEnd(8)} [Aktualny]`);
       unchangedCount += 1;
       continue;
     }
 
+    // 3. Wersja w Hubie nowsza niż lokalna - pobieramy downstream
     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}]`);
+      if (effectiveLocalVer) {
+        out(`  \x1b[33m↑\x1b[0m ${s.full_slug.padEnd(38)} v${latestVer.padEnd(8)} [Zaktualizowano z v${effectiveLocalVer}]`);
         updatedCount += 1;
       } else {
         out(`  \x1b[36m+\x1b[0m ${s.full_slug.padEnd(38)} v${latestVer.padEnd(8)} [Zainstalowano]`);
@@ -436,17 +616,89 @@ async function cmdSkillSync(flags, out, err) {
     }
   }
 
+  // 4. Sprawdź lokalne skille, których w ogóle nie ma w Hubie
+  const unpushedLocalSkills = [];
+  for (const [lSlug, lk] of localSkills.entries()) {
+    if (!hubSlugs.has(lSlug)) {
+      unpushedLocalSkills.push(lk);
+    }
+  }
+
+  if (unpushedLocalSkills.length > 0) {
+    for (const ul of unpushedLocalSkills) {
+      if (shouldPush) {
+        try {
+          out(`  \x1b[35m↑ PUSH\x1b[0m ${ul.slug.padEnd(36)} v${ul.version} → Hub (nowy skill lokalny)...`);
+          const pushRes = await skillsHub.pushSkill(ul.dir, {
+            version: ul.version,
+            changelog: flags.changelog || `Inicjalna publikacja skilla lokalnego v${ul.version}`,
+          });
+          if (pushRes.ok) {
+            out(`  \x1b[32m✓ PUSHED\x1b[0m ${ul.slug.padEnd(34)} v${ul.version} opublikowano w DeerSkills Hub.`);
+            pushedCount += 1;
+          } else {
+            out(`  \x1b[31m✗ PUSH BŁĄD\x1b[0m ${ul.slug}: ${pushRes.data?.error || 'Błąd publikacji'}`);
+          }
+        } catch (pe) {
+          out(`  \x1b[31m✗ PUSH BŁĄD\x1b[0m ${ul.slug}: ${pe.message}`);
+        }
+      } else {
+        out(`  \x1b[90m○\x1b[0m ${ul.slug.padEnd(38)} v${ul.version.padEnd(8)} [Tylko lokalnie (brak w Hubie)]`);
+      }
+    }
+  }
+
   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 (pushedCount > 0) {
+    out(`   • Wypchnięte do Hubu:      \x1b[35m${pushedCount}\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');
+  out('─'.repeat(72));
+
+  // Alert i komunikat o możliwości wypchnięcia (jeśli nie użyto --push, a wykryto lokalne nowości)
+  if (!shouldPush && (aheadSkills.length > 0 || unpushedLocalSkills.length > 0)) {
+    out('\n\x1b[35m┌─────────────────────────────────────────────────────────────────────────────┐\x1b[0m');
+    out('\x1b[35m│\x1b[0m  \x1b[1m💡 WYKRYTO SKILLE Z LOKALNYMI ZMIANAMI GOTOWYMI DO WYPCHNIĘCIA (AHEAD)\x1b[0m     \x1b[35m│\x1b[0m');
+    out('\x1b[35m├─────────────────────────────────────────────────────────────────────────────┤\x1b[0m');
+    out('\x1b[35m│\x1b[0m  Domyślny \x1b[36msync\x1b[0m pobiera nowości z Hubu i chroni Twoje lokalne pliki.          \x1b[35m│\x1b[0m');
+    out('\x1b[35m│\x1b[0m  Posiadasz skille nowsze niż w rejestrze firmowym DeerSkills Hub:           \x1b[35m│\x1b[0m');
+
+    const allNotices = [];
+    for (const a of aheadSkills) {
+      allNotices.push(`  • ${a.slug}: lokalnie v${a.localVersion} > w Hubie v${a.hubVersion}`);
+    }
+    for (const u of unpushedLocalSkills) {
+      allNotices.push(`  • ${u.slug}: lokalnie v${u.version} (nowy, brak w Hubie)`);
+    }
+
+    const maxToShow = 6;
+    for (let i = 0; i < Math.min(allNotices.length, maxToShow); i++) {
+      out(`\x1b[35m│\x1b[0m  \x1b[33m${allNotices[i].padEnd(73)}\x1b[0m\x1b[35m│\x1b[0m`);
+    }
+    if (allNotices.length > maxToShow) {
+      const moreText = `  ... i jeszcze ${allNotices.length - maxToShow} innych skilli z lokalnymi zmianami`;
+      out(`\x1b[35m│\x1b[0m  \x1b[90m${moreText.padEnd(73)}\x1b[0m\x1b[35m│\x1b[0m`);
+    }
+
+    out('\x1b[35m├─────────────────────────────────────────────────────────────────────────────┤\x1b[0m');
+    out('\x1b[35m│\x1b[0m  \x1b[1mAby wypchnąć zmiany do Hubu dla zespołu / firmy:\x1b[0m                           \x1b[35m│\x1b[0m');
+    if (aheadSkills.length > 0) {
+      out(`\x1b[35m│\x1b[0m    ▶ Pojedynczo:  \x1b[36mdeertools skill push ${aheadSkills[0].dir}\x1b[0m`);
+    }
+    out('\x1b[35m│\x1b[0m    ▶ Automatycznie (dwukierunkowo):                                         \x1b[35m│\x1b[0m');
+    out('\x1b[35m│\x1b[0m       \x1b[32mdeertools sync --push\x1b[0m   (lub: \x1b[32mdeertools skill sync --push\x1b[0m)                \x1b[35m│\x1b[0m');
+    out('\x1b[35m└─────────────────────────────────────────────────────────────────────────────┘\x1b[0m\n');
+  } else {
+    out('');
+  }
 }
 
 async function cmdSkillInstall(target, flags, out, err) {
@@ -985,4 +1237,6 @@ module.exports = {
   cmdSkillShare,
   checkSkillUpdates,
   updateSkills,
+  scanLocalSkills,
+  inspectSkillForAgents,
 };

package/src/skills-hub.js

@@ -5,6 +5,7 @@ const crypto = require('crypto');
 const credentials = require('./credentials');
 const { fetchText } = require('./http');
 const { parseFrontmatterName } = require('./openapi');
+const { compareSemver } = require('./updater');
 
 const DEFAULT_API_BASE = 'https://ezspmlsnmxuhtzvwrnoj.supabase.co/functions/v1/skills-api';
 const SECRET_PATTERNS = [
@@ -272,6 +273,7 @@ async function pushSkill(skillDir, { version = null, bump = 'patch', changelog =
   let title = slug;
   let description = '';
   let frontmatterTags = [];
+  let frontmatterVersion = null;
   if (skillContent.startsWith('---')) {
     const parts = skillContent.split('---', 2);
     if (parts.length >= 2) {
@@ -282,6 +284,8 @@ async function pushSkill(skillDir, { version = null, bump = 'patch', changelog =
       }
       const descMatch = parts[1].match(/^description:\s*(.+)$/m);
       if (descMatch) description = descMatch[1].trim();
+      const verMatch = parts[1].match(/^version:\s*['"]?([0-9]+\.[0-9]+(\.[0-9]+)?(-[a-zA-Z0-9.]+)?)/im);
+      if (verMatch) frontmatterVersion = verMatch[1].trim();
       frontmatterTags = extractFrontmatterTags(parts[1]);
     }
   }
@@ -301,9 +305,15 @@ async function pushSkill(skillDir, { version = null, bump = 'patch', changelog =
     try {
       const existing = await getSkill(slug);
       const latestVer = existing?.data?.skill?.latest_version;
-      targetVersion = latestVer ? bumpVersion(latestVer, bump) : '1.0.0';
+      if (frontmatterVersion && latestVer && compareSemver(frontmatterVersion, latestVer) > 0) {
+        targetVersion = frontmatterVersion;
+      } else if (frontmatterVersion && !latestVer) {
+        targetVersion = frontmatterVersion;
+      } else {
+        targetVersion = latestVer ? bumpVersion(latestVer, bump) : (frontmatterVersion || '1.0.0');
+      }
     } catch (_) {
-      targetVersion = '1.0.0';
+      targetVersion = frontmatterVersion || '1.0.0';
     }
   }