pnpm-plugin-skills 0.1.1 → 0.2.0

package/README.md

@@ -25,7 +25,7 @@ Then create a `skills.json` in your project root:
 ```jsonc
 {
   "installDir": ".agents/skills",
-  "linkTargets": [".cursor/skills"],
+  "linkTargets": [".claude/skills"],
   "skills": {
     "my-skill": "https://github.com/owner/repo.git#path:/skills/my-skill"
   }

package/dist/index.js

@@ -6436,9 +6436,14 @@ var __webpack_exports__ = {};
     const external_node_path_namespaceObject = require("node:path");
     var dist = __webpack_require__("../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/index.js");
     const external_node_crypto_namespaceObject = require("node:crypto");
+    const external_node_os_namespaceObject = require("node:os");
     const external_node_child_process_namespaceObject = require("node:child_process");
     const external_node_util_namespaceObject = require("node:util");
-    const external_node_os_namespaceObject = require("node:os");
+    if ("u" > typeof process) {
+        "u" > typeof Deno && "string" == typeof Deno.version?.deno || "u" > typeof Bun && Bun.version;
+        process.platform, process.arch, process.version;
+        process.argv;
+    } else "u" < typeof navigator || (navigator.platform, navigator.userAgent);
     const external_node_process_namespaceObject = require("node:process");
     require("node:readline");
     __webpack_require__("../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js");
@@ -6642,19 +6647,58 @@ var __webpack_exports__ = {};
         return `sha256-${(0, external_node_crypto_namespaceObject.createHash)('sha256').update(content).digest('hex')}`;
     }
     const execFileAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.execFile);
+    async function resolveGitCommitByLsRemote(url, target) {
+        try {
+            const { stdout } = await execFileAsync('git', [
+                'ls-remote',
+                url,
+                target,
+                `${target}^{}`
+            ]);
+            const lines = stdout.trim().split('\n').map((line)=>line.trim()).filter(Boolean);
+            const peeledLine = lines.find((line)=>line.endsWith('^{}'));
+            const resolvedLine = peeledLine ?? lines[0];
+            return resolvedLine?.split('\t')[0]?.trim() || null;
+        } catch  {
+            return null;
+        }
+    }
+    async function resolveGitCommitByClone(url, target) {
+        const checkoutRoot = await (0, promises_namespaceObject.mkdtemp)(external_node_path_namespaceObject.join((0, external_node_os_namespaceObject.tmpdir)(), 'skills-pm-git-ref-'));
+        try {
+            await execFileAsync('git', [
+                'clone',
+                '--bare',
+                '--quiet',
+                url,
+                checkoutRoot
+            ]);
+            const { stdout } = await execFileAsync('git', [
+                'rev-parse',
+                '--verify',
+                `${target}^{commit}`
+            ], {
+                cwd: checkoutRoot
+            });
+            return stdout.trim().split('\n')[0]?.trim() || null;
+        } catch  {
+            return null;
+        } finally{
+            await (0, promises_namespaceObject.rm)(checkoutRoot, {
+                recursive: true,
+                force: true
+            }).catch(()=>{});
+        }
+    }
     async function resolveGitCommit(url, ref) {
         const target = ref ?? 'HEAD';
-        const { stdout } = await execFileAsync('git', [
-            'ls-remote',
-            url,
-            target
-        ]);
-        const line = stdout.trim().split('\n')[0];
-        const commit = line?.split('\t')[0]?.trim();
-        if (!commit) throw new Error(`Unable to resolve git ref ${target} for ${url}`);
-        return commit;
+        const commit = await resolveGitCommitByLsRemote(url, target);
+        if (commit) return commit;
+        const clonedCommit = await resolveGitCommitByClone(url, target);
+        if (clonedCommit) return clonedCommit;
+        throw new Error(`Unable to resolve git ref ${target} for ${url}`);
     }
-    async function createLockEntry(cwd, specifier) {
+    async function resolveLockEntry(cwd, specifier) {
         const normalized = normalizeSpecifier(specifier);
         if ('file' === normalized.type) {
             const sourceRoot = external_node_path_namespaceObject.resolve(cwd, normalized.source.slice(5));
@@ -6664,7 +6708,7 @@ var __webpack_exports__ = {};
                     specifier: normalized.normalized,
                     resolution: {
                         type: 'file',
-                        path: sourceRoot
+                        path: external_node_path_namespaceObject.relative(cwd, sourceRoot) || '.'
                     },
                     digest: sha256(`${sourceRoot}:${normalized.path}`)
                 }
@@ -6691,7 +6735,7 @@ var __webpack_exports__ = {};
     async function syncSkillsLock(cwd, manifest, existingLock) {
         const nextSkills = {};
         for (const specifier of Object.values(manifest.skills)){
-            const { skillName, entry } = await createLockEntry(cwd, specifier);
+            const { skillName, entry } = await resolveLockEntry(cwd, specifier);
             nextSkills[skillName] = entry;
         }
         return {
@@ -6772,6 +6816,54 @@ var __webpack_exports__ = {};
         });
     }
     const materializeGitSkill_execFileAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.execFile);
+    async function checkoutCommit(checkoutRoot, commit) {
+        await materializeGitSkill_execFileAsync('git', [
+            'checkout',
+            commit
+        ], {
+            cwd: checkoutRoot
+        });
+    }
+    async function fetchCommitFallback(checkoutRoot, commit) {
+        try {
+            await materializeGitSkill_execFileAsync('git', [
+                'fetch',
+                '--depth',
+                '1',
+                'origin',
+                commit
+            ], {
+                cwd: checkoutRoot
+            });
+            return;
+        } catch  {}
+        try {
+            await materializeGitSkill_execFileAsync('git', [
+                'fetch',
+                '--tags',
+                'origin'
+            ], {
+                cwd: checkoutRoot
+            });
+            return;
+        } catch  {}
+        try {
+            await materializeGitSkill_execFileAsync('git', [
+                'fetch',
+                '--unshallow',
+                'origin'
+            ], {
+                cwd: checkoutRoot
+            });
+        } catch  {
+            await materializeGitSkill_execFileAsync('git', [
+                'fetch',
+                'origin'
+            ], {
+                cwd: checkoutRoot
+            });
+        }
+    }
     async function materializeGitSkill(rootDir, skillName, repoUrl, commit, sourcePath, installDir) {
         const checkoutRoot = await (0, promises_namespaceObject.mkdtemp)(external_node_path_namespaceObject.join((0, external_node_os_namespaceObject.tmpdir)(), 'skills-pm-git-checkout-'));
         try {
@@ -6782,12 +6874,12 @@ var __webpack_exports__ = {};
                 repoUrl,
                 checkoutRoot
             ]);
-            if (commit && 'HEAD' !== commit) await materializeGitSkill_execFileAsync('git', [
-                'checkout',
-                commit
-            ], {
-                cwd: checkoutRoot
-            });
+            if (commit && 'HEAD' !== commit) try {
+                await checkoutCommit(checkoutRoot, commit);
+            } catch  {
+                await fetchCommitFallback(checkoutRoot, commit);
+                await checkoutCommit(checkoutRoot, commit);
+            }
             const skillDocPath = external_node_path_namespaceObject.join(checkoutRoot, sourcePath.replace(/^\//, ''), 'SKILL.md');
             await (0, promises_namespaceObject.readFile)(skillDocPath, 'utf8');
             await materializeLocalSkill(rootDir, skillName, checkoutRoot, sourcePath, installDir);
@@ -6835,21 +6927,17 @@ var __webpack_exports__ = {};
             }
         } catch  {}
     }
+    const installStageHooks = {
+        beforeFetch: async (_rootDir, _manifest, _lockfile)=>{}
+    };
     function extractSkillPath(specifier, skillName) {
         const marker = '#path:';
         const index = specifier.indexOf(marker);
         if (index >= 0) return specifier.slice(index + marker.length);
         return `/${skillName}`;
     }
-    async function installSkills(rootDir) {
-        const manifest = await readSkillsManifest(rootDir);
-        if (!manifest) return {
-            status: 'skipped',
-            reason: 'manifest-missing'
-        };
-        const currentLock = await readSkillsLock(rootDir);
-        const lockfile = await syncSkillsLock(rootDir, manifest, currentLock);
-        await writeSkillsLock(rootDir, lockfile);
+    async function fetchSkillsFromLock(rootDir, manifest, lockfile) {
+        await installStageHooks.beforeFetch(rootDir, manifest, lockfile);
         const lockDigest = sha256(JSON.stringify(lockfile));
         const state = await readInstallState(rootDir);
         if (state?.lockDigest === lockDigest) return {
@@ -6860,10 +6948,15 @@ var __webpack_exports__ = {};
         const linkTargets = manifest.linkTargets ?? [];
         await pruneManagedSkills(rootDir, installDir, linkTargets, Object.keys(lockfile.skills));
         for (const [skillName, entry] of Object.entries(lockfile.skills)){
-            if ('file' === entry.resolution.type) await materializeLocalSkill(rootDir, skillName, entry.resolution.path, extractSkillPath(entry.specifier, skillName), installDir);
-            else if ('git' === entry.resolution.type) await materializeGitSkill(rootDir, skillName, entry.resolution.url, entry.resolution.commit, entry.resolution.path, installDir);
-            else throw new Error(`Unsupported resolution type in 0.1.0 core flow: ${entry.resolution.type}`);
-            for (const linkTarget of linkTargets)await linkSkill(rootDir, installDir, linkTarget, skillName);
+            if ('file' === entry.resolution.type) {
+                await materializeLocalSkill(rootDir, skillName, external_node_path_namespaceObject.resolve(rootDir, entry.resolution.path), extractSkillPath(entry.specifier, skillName), installDir);
+                continue;
+            }
+            if ('git' === entry.resolution.type) {
+                await materializeGitSkill(rootDir, skillName, entry.resolution.url, entry.resolution.commit, entry.resolution.path, installDir);
+                continue;
+            }
+            throw new Error(`Unsupported resolution type in 0.1.0 core flow: ${entry.resolution.type}`);
         }
         await writeInstallState(rootDir, {
             lockDigest,
@@ -6872,6 +6965,31 @@ var __webpack_exports__ = {};
             installerVersion: '0.1.0',
             installedAt: new Date().toISOString()
         });
+        return {
+            status: 'fetched',
+            fetched: Object.keys(lockfile.skills)
+        };
+    }
+    async function linkSkillsFromLock(rootDir, manifest, lockfile) {
+        const installDir = manifest.installDir ?? '.agents/skills';
+        const linkTargets = manifest.linkTargets ?? [];
+        for (const skillName of Object.keys(lockfile.skills))for (const linkTarget of linkTargets)await linkSkill(rootDir, installDir, linkTarget, skillName);
+        return {
+            status: 'linked',
+            linked: Object.keys(lockfile.skills)
+        };
+    }
+    async function installSkills(rootDir) {
+        const manifest = await readSkillsManifest(rootDir);
+        if (!manifest) return {
+            status: 'skipped',
+            reason: 'manifest-missing'
+        };
+        const currentLock = await readSkillsLock(rootDir);
+        const lockfile = await syncSkillsLock(rootDir, manifest, currentLock);
+        await fetchSkillsFromLock(rootDir, manifest, lockfile);
+        await linkSkillsFromLock(rootDir, manifest, lockfile);
+        await writeSkillsLock(rootDir, lockfile);
         return {
             status: 'installed',
             installed: Object.keys(lockfile.skills)
@@ -6880,6 +6998,10 @@ var __webpack_exports__ = {};
     async function installCommand(options) {
         return installSkills(options.cwd);
     }
+    var package_namespaceObject = {
+        rE: "0.2.0"
+    };
+    package_namespaceObject.rE;
     async function preResolution(options = {}) {
         const lockfileDir = options.lockfileDir;
         if (!lockfileDir) return;