@deerdesign/deertools 1.2.7 → 1.2.8

package/package.json

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

package/src/commands.js

@@ -384,13 +384,19 @@ async function cmdSkill(pos, flags) {
   if (sub === 'update') {
     return skillCommands.cmdSkillUpdate(flags, out, err);
   }
+  if (sub === 'versions' || sub === 'history') {
+    return skillCommands.cmdSkillVersions(pos[1], flags, out, err);
+  }
+  if (sub === 'diff' || sub === 'compare') {
+    return skillCommands.cmdSkillDiff(pos.slice(1), flags, out, err);
+  }
   if (sub === 'promote') {
     return skillCommands.cmdSkillPromote(pos[1], flags, out, err);
   }
   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 push [katalog] [--version <x.y.z>]\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 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);
 }
 
 
@@ -531,6 +537,8 @@ Integracje MCP i Agenci AI (DeerSkills Hub):
   deertools skill list [--tag <tag>]                    Przegląda skille globalne i użytkownika w DeerSkills Hub.
   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 update [slug]                         Aktualizuje zainstalowane skille do najnowszej wersji.
   deertools skill promote <slug>                        Zgłasza nominację skilla do oficjalnego katalogu globalnego.

package/src/skill-commands.js

@@ -120,7 +120,11 @@ async function cmdSkillInstall(target, flags, out, err) {
         for (const file of versionData.files_manifest) {
           const targetFile = path.join(baseDir, file.path);
           fs.mkdirSync(path.dirname(targetFile), { recursive: true });
-          fs.writeFileSync(targetFile, file.content, 'utf8');
+          if (file.encoding === 'base64') {
+            fs.writeFileSync(targetFile, Buffer.from(file.content, 'base64'));
+          } else {
+            fs.writeFileSync(targetFile, file.content, 'utf8');
+          }
         }
       }
     } catch (e) {
@@ -145,8 +149,9 @@ async function cmdSkillPush(dir, flags, out, err) {
   out(`Analizuję folder skilla: ${targetDir}...`);
 
   const res = await skillsHub.pushSkill(targetDir, {
-    version: flags.version || '1.0.0',
-    changelog: flags.changelog || 'Aktualizacja przez DeerTools CLI',
+    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',
   });
 
@@ -154,12 +159,138 @@ async function cmdSkillPush(dir, flags, out, err) {
     throw new Error(`Nie udało się opublikować skilla (${res.status}): ${res.data?.error || 'Błąd serwera'}`);
   }
 
-  out(`✓ Pomyślnie opublikowano skill w DeerSkills Hub:`);
-  out(`  • Pełny identyfikator: ${res.data.skill.full_slug}`);
-  out(`  • Wersja: ${res.data.version.version}`);
-  out(`  • Widoczność: ${res.data.skill.visibility}`);
-  out(`  • Komenda do instalacji przez innych:`);
-  out(`      deertools skill install ${res.data.skill.full_slug}`);
+  const skill = res.data.skill || {};
+  const version = res.data.version || res.data.selected_version || {};
+  const manifest = version.files_manifest || [];
+  out(`\n✓ Pomyślnie opublikowano skill w DeerSkills Hub:`);
+  out(`  • Identyfikator: \x1b[1m${skill.full_slug || skill.slug}\x1b[0m`);
+  out(`  • Wersja:        \x1b[32mv${version.version || skill.latest_version}\x1b[0m`);
+  if (version.changelog) {
+    out(`  • Changelog:     \x1b[33m${version.changelog}\x1b[0m`);
+  }
+  out(`  • Paczka:        ${manifest.length + 1} plików (SKILL.md + ${manifest.length} plików w podkatalogach)`);
+  out(`  • Widoczność:    ${skill.visibility || 'shared'}`);
+  out(`\nAby zainstalować tę wersję w projekcie:\n  \x1b[36mdeertools skill install ${skill.full_slug || skill.slug}@${version.version || skill.latest_version}\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}”...`);
+  const res = await skillsHub.getSkill(slug);
+  if (!res.ok || !res.data?.skill) {
+    throw new Error(`Nie znaleziono skilla „${slug}” (${res.status}): ${res.data?.error || 'Błąd'}`);
+  }
+  const { skill, versions = [] } = res.data;
+  out(`\n=== Historia wydań: ${skill.full_slug || skill.slug} (${skill.title || skill.slug}) ===\n`);
+  if (versions.length === 0) {
+    out('Brak opublikowanych wersji w rejestrze.');
+    return;
+  }
+  const lock = readLock();
+  const installedVer = lock.skills?.[skill.slug]?.version;
+
+  for (let i = 0; i < versions.length; i++) {
+    const v = versions[i];
+    const isLatest = v.version === skill.latest_version;
+    const isInstalled = installedVer && v.version === installedVer;
+    const bullet = isLatest ? '\x1b[32m●\x1b[0m' : '○';
+    const tag = [
+      isLatest ? '\x1b[32m(najnowsza)\x1b[0m' : null,
+      isInstalled ? '\x1b[36m[zainstalowana]\x1b[0m' : null,
+    ].filter(Boolean).join(' ');
+
+    const dateStr = v.created_at ? new Date(v.created_at).toLocaleDateString('pl-PL') : '—';
+    const fileCount = (v.files_manifest && Array.isArray(v.files_manifest) ? v.files_manifest.length : 0) + 1;
+    out(`${bullet} \x1b[1mv${v.version}\x1b[0m ${tag} — ${dateStr}`);
+    if (v.changelog) {
+      out(`  Changelog: \x1b[33m${v.changelog}\x1b[0m`);
+    }
+    out(`  Paczka:    ${fileCount} ${fileCount === 1 ? 'plik' : 'plików'} • SHA-256: ${(v.sha256_checksum || '').slice(0, 16)}...`);
+    out(`  Komenda:   deertools skill install ${skill.slug}@${v.version}\n`);
+  }
+}
+
+async function cmdSkillDiff(args, flags, out, err) {
+  const slug = Array.isArray(args) ? args[0] : args;
+  if (!slug) throw new Error('Podaj slug skilla, np. deertools skill diff deer-technical-documentation [wersjaA] [wersjaB]');
+  const verA = Array.isArray(args) ? args[1] : null;
+  const verB = Array.isArray(args) ? args[2] : null;
+
+  out(`Pobieram dane do porównania dla „${slug}”...`);
+  const res = await skillsHub.getSkill(slug);
+  if (!res.ok || !res.data?.skill) {
+    throw new Error(`Nie znaleziono skilla „${slug}”: ${res.data?.error || 'Błąd'}`);
+  }
+  const { skill, versions = [] } = res.data;
+  if (versions.length < 1) {
+    out('Brak wystarczającej liczby wersji do porównania.');
+    return;
+  }
+
+  let objA = null;
+  let objB = null;
+
+  if (verA && verB) {
+    objA = versions.find((v) => v.version === verA);
+    objB = versions.find((v) => v.version === verB);
+    if (!objA) throw new Error(`Nie znaleziono wersji ${verA}.`);
+    if (!objB) throw new Error(`Nie znaleziono wersji ${verB}.`);
+  } else if (verA) {
+    objA = versions.find((v) => v.version === verA);
+    objB = versions.find((v) => v.version === skill.latest_version) || versions[0];
+    if (!objA) throw new Error(`Nie znaleziono wersji ${verA}.`);
+  } else {
+    const lock = readLock();
+    const installed = lock.skills?.[skill.slug]?.version;
+    if (installed && installed !== skill.latest_version) {
+      objA = versions.find((v) => v.version === installed);
+      objB = versions.find((v) => v.version === skill.latest_version);
+    } else if (versions.length >= 2) {
+      objA = versions[1];
+      objB = versions[0];
+    } else {
+      out(`Dostępna jest tylko jedna wersja (v${versions[0].version}). Brak wcześniejszych wydań do porównania.`);
+      return;
+    }
+  }
+
+  out(`\n=== Porównanie: ${skill.slug} v${objA.version} → v${objB.version} ===\n`);
+  if (objB.changelog) {
+    out(`Opis zmian (v${objB.version}): \x1b[33m${objB.changelog}\x1b[0m\n`);
+  }
+
+  // 1. Zmiany w strukturze plików paczki
+  const manA = objA.files_manifest || [];
+  const manB = objB.files_manifest || [];
+  const comp = skillsHub.compareManifests(manA, manB);
+
+  out(`Pliki w paczce:`);
+  if (comp.added.length === 0 && comp.removed.length === 0 && comp.modified.length === 0) {
+    out(`  (brak zmian w strukturze plików paczki)`);
+  } else {
+    for (const f of comp.added) out(`  \x1b[32m+ ${f.path}\x1b[0m (nowy plik, ${Math.round((f.size || 0) / 1024 * 10) / 10 || '<1'} KB)`);
+    for (const f of comp.removed) out(`  \x1b[31m- ${f.path}\x1b[0m (usunięty plik)`);
+    for (const f of comp.modified) out(`  \x1b[33m~ ${f.path}\x1b[0m (zmodyfikowany plik)`);
+  }
+  out('');
+
+  // 2. Diff tekstu SKILL.md
+  out(`Różnice w SKILL.md (v${objA.version} → v${objB.version}):`);
+  const diff = skillsHub.diffLines(objA.skill_md_content, objB.skill_md_content);
+  let hasDiff = false;
+  for (const p of diff) {
+    if (p.type === 'added') {
+      out(`\x1b[32m+ ${p.line}\x1b[0m`);
+      hasDiff = true;
+    } else if (p.type === 'removed') {
+      out(`\x1b[31m- ${p.line}\x1b[0m`);
+      hasDiff = true;
+    }
+  }
+  if (!hasDiff) {
+    out(`  (brak zmian w pliku SKILL.md)`);
+  }
+  out('');
 }
 
 async function cmdSkillUpdate(flags, out, err) {
@@ -223,4 +354,6 @@ module.exports = {
   cmdSkillPush,
   cmdSkillUpdate,
   cmdSkillPromote,
+  cmdSkillVersions,
+  cmdSkillDiff,
 };

package/src/skills-hub.js

@@ -91,15 +91,127 @@ async function getSkill(slug, version = null) {
   return hubRequest(`/skills/${encodeURIComponent(slug)}${qs}`);
 }
 
-async function pushSkill(skillDir, { version = '1.0.0', changelog = 'Publikacja przez DeerTools CLI', visibility = 'shared' } = {}) {
-  const mdPath = fs.existsSync(skillDir) && fs.statSync(skillDir).isFile()
-    ? skillDir
-    : path.join(skillDir, 'SKILL.md');
+function bumpVersion(currentVersion = '1.0.0', type = 'patch') {
+  const parts = String(currentVersion || '1.0.0').replace(/^v/, '').split('.').map((n) => parseInt(n, 10) || 0);
+  let [major = 1, minor = 0, patch = 0] = parts;
+  if (type === 'major') {
+    major += 1;
+    minor = 0;
+    patch = 0;
+  } else if (type === 'minor') {
+    minor += 1;
+    patch = 0;
+  } else {
+    patch += 1;
+  }
+  return `${major}.${minor}.${patch}`;
+}
+
+function getGitCommitMessage(dir) {
+  try {
+    const { execSync } = require('child_process');
+    const msg = execSync('git log -1 --pretty=%B', { cwd: dir, stdio: ['ignore', 'pipe', 'ignore'], timeout: 2000 })
+      .toString('utf8')
+      .trim();
+    return msg || null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function isTextBuffer(buf) {
+  const max = Math.min(buf.length, 512);
+  for (let i = 0; i < max; i++) {
+    if (buf[i] === 0) return false;
+  }
+  return true;
+}
+
+function gatherSkillBundle(skillDir) {
+  const isFile = fs.existsSync(skillDir) && fs.statSync(skillDir).isFile();
+  const mdPath = isFile ? skillDir : path.join(skillDir, 'SKILL.md');
 
   if (!fs.existsSync(mdPath)) {
     throw new Error(`Nie znaleziono pliku SKILL.md w ścieżce: ${skillDir}`);
   }
 
+  const baseDir = isFile ? path.dirname(skillDir) : skillDir;
+  const manifest = [];
+  const ignored = new Set(['.git', 'node_modules', '.DS_Store', '__pycache__', '.pytest_cache', '.turbo']);
+
+  function walk(currentDir, relPrefix = '') {
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const ent of entries) {
+      if (ignored.has(ent.name) || ent.name.startsWith('.')) continue;
+      const fullPath = path.join(currentDir, ent.name);
+      const relPath = relPrefix ? `${relPrefix}/${ent.name}` : ent.name;
+
+      if (ent.isDirectory()) {
+        walk(fullPath, relPath);
+      } else if (ent.isFile() && relPath !== 'SKILL.md') {
+        const buf = fs.readFileSync(fullPath);
+        const isText = isTextBuffer(buf);
+        const content = isText ? buf.toString('utf8') : buf.toString('base64');
+        const encoding = isText ? 'utf8' : 'base64';
+        const sha = crypto.createHash('sha256').update(buf).digest('hex');
+
+        manifest.push({
+          path: relPath,
+          content,
+          encoding,
+          size: buf.length,
+          sha256: sha,
+        });
+      }
+    }
+  }
+
+  walk(baseDir);
+  return { mdPath, baseDir, manifest };
+}
+
+function diffLines(textA, textB) {
+  const linesA = String(textA || '').split('\n');
+  const linesB = String(textB || '').split('\n');
+  const diff = [];
+  let i = 0, j = 0;
+  while (i < linesA.length || j < linesB.length) {
+    if (i < linesA.length && j < linesB.length && linesA[i] === linesB[j]) {
+      diff.push({ type: 'same', line: linesA[i] });
+      i++; j++;
+    } else if (j < linesB.length && (!linesA.includes(linesB[j]) || linesB.indexOf(linesA[i]) > j)) {
+      diff.push({ type: 'added', line: linesB[j] });
+      j++;
+    } else if (i < linesA.length) {
+      diff.push({ type: 'removed', line: linesA[i] });
+      i++;
+    } else {
+      diff.push({ type: 'added', line: linesB[j] });
+      j++;
+    }
+  }
+  return diff;
+}
+
+function compareManifests(manifestA = [], manifestB = []) {
+  const mapA = new Map((manifestA || []).map((f) => [f.path, f]));
+  const mapB = new Map((manifestB || []).map((f) => [f.path, f]));
+  const added = [];
+  const removed = [];
+  const modified = [];
+
+  for (const [p, f] of mapB) {
+    if (!mapA.has(p)) added.push(f);
+    else if (mapA.get(p).sha256 !== f.sha256) modified.push({ path: p, old: mapA.get(p), new: f });
+  }
+  for (const [p, f] of mapA) {
+    if (!mapB.has(p)) removed.push(f);
+  }
+  return { added, removed, modified };
+}
+
+async function pushSkill(skillDir, { version = null, bump = 'patch', changelog = null, visibility = 'shared' } = {}) {
+  const { mdPath, baseDir, manifest } = gatherSkillBundle(skillDir);
   const skillContent = fs.readFileSync(mdPath, 'utf8');
 
   // 1. Skanowanie sekretów
@@ -109,8 +221,18 @@ async function pushSkill(skillDir, { version = '1.0.0', changelog = 'Publikacja
     throw new Error(`BLOKADA BEZPIECZEŃSTWA: Wykryto potencjalne klucze API w treści SKILL.md [${list}]. Usuń sekrety przed publikacją!`);
   }
 
+  for (const file of manifest) {
+    if (file.encoding === 'utf8') {
+      const fScan = scanForSecrets(file.content);
+      if (!fScan.safe) {
+        const list = fScan.matches.map((m) => `${m.name} (${m.count})`).join(', ');
+        throw new Error(`BLOKADA BEZPIECZEŃSTWA: Wykryto potencjalne klucze w ${file.path} [${list}]. Usuń sekrety przed publikacją!`);
+      }
+    }
+  }
+
   // 2. Parsowanie frontmatter
-  let slug = path.basename(path.dirname(mdPath));
+  let slug = path.basename(baseDir);
   let title = slug;
   let description = '';
   if (skillContent.startsWith('---')) {
@@ -126,39 +248,35 @@ async function pushSkill(skillDir, { version = '1.0.0', changelog = 'Publikacja
     }
   }
 
-  // 3. Odczyt dodatkowych plików (references/, scripts/, assets/)
-  const dir = path.dirname(mdPath);
-  const filesManifest = [];
-  const allowedDirs = ['references', 'scripts', 'assets'];
-
-  for (const sub of allowedDirs) {
-    const subPath = path.join(dir, sub);
-    if (fs.existsSync(subPath) && fs.statSync(subPath).isDirectory()) {
-      const files = fs.readdirSync(subPath);
-      for (const f of files) {
-        const fullF = path.join(subPath, f);
-        if (fs.statSync(fullF).isFile() && !f.startsWith('.')) {
-          try {
-            const rel = path.join(sub, f);
-            const content = fs.readFileSync(fullF, 'utf8');
-            filesManifest.push({ path: rel, content });
-          } catch (_) {
-            // binarne pomijamy w manifeście tekstowym
-          }
-        }
-      }
+  // 3. Automatyczne ustalenie wersji, jeśli nie podano
+  let targetVersion = version;
+  if (!targetVersion) {
+    try {
+      const existing = await getSkill(slug);
+      const latestVer = existing?.data?.skill?.latest_version;
+      targetVersion = latestVer ? bumpVersion(latestVer, bump) : '1.0.0';
+    } catch (_) {
+      targetVersion = '1.0.0';
     }
   }
 
+  // 4. Automatyczny opis z ostatniego commita git, jeśli nie podano changelog
+  let finalChangelog = changelog;
+  if (!finalChangelog) {
+    const gitMsg = getGitCommitMessage(baseDir);
+    finalChangelog = gitMsg || 'Aktualizacja paczki przez DeerTools CLI';
+  }
+
   const body = {
     slug,
     title,
     summary: description,
-    version,
-    changelog,
+    version: targetVersion,
+    changelog: finalChangelog,
     visibility,
+    skill_md: skillContent,
     skill_md_content: skillContent,
-    files_manifest: filesManifest,
+    files_manifest: manifest,
   };
 
   return hubRequest('/skills/push', { method: 'POST', body });
@@ -194,6 +312,11 @@ module.exports = {
   listSkills,
   getSkill,
   pushSkill,
+  bumpVersion,
+  gatherSkillBundle,
+  diffLines,
+  compareManifests,
+  getGitCommitMessage,
   listMcpServers,
   getProducts,
   getDocs,