pnpm-plugin-skills 0.2.0 → 0.3.0

package/dist/index.js

@@ -6432,18 +6432,18 @@ var __webpack_exports__ = {};
     __webpack_require__.d(__webpack_exports__, {
         preResolution: ()=>preResolution
     });
-    const promises_namespaceObject = require("node:fs/promises");
-    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");
     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 promises_namespaceObject = require("node:fs/promises");
+    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_child_process_namespaceObject = require("node:child_process");
+    const external_node_os_namespaceObject = require("node:os");
+    const external_node_util_namespaceObject = require("node:util");
+    const external_node_crypto_namespaceObject = require("node:crypto");
     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");
@@ -6574,39 +6574,267 @@ var __webpack_exports__ = {};
     new RegExp(`(?:\\${ke}(?<code>\\d+)m|\\${Se}(?<uri>.*)${Ce})`, "y");
     dist_I("\u2500", "-"), dist_I("\u2501", "="), dist_I("\u2588", "#");
     (0, external_node_util_namespaceObject.styleText)("gray", dist_h);
+    var package_namespaceObject = {
+        rE: "0.3.0"
+    };
+    var codes_ErrorCode = /*#__PURE__*/ function(ErrorCode) {
+        ErrorCode["FILE_NOT_FOUND"] = "ENOENT";
+        ErrorCode["PERMISSION_DENIED"] = "EACCES";
+        ErrorCode["FILE_EXISTS"] = "EEXIST";
+        ErrorCode["FS_ERROR"] = "EFS";
+        ErrorCode["GIT_CLONE_FAILED"] = "EGITCLONE";
+        ErrorCode["GIT_FETCH_FAILED"] = "EGITFETCH";
+        ErrorCode["GIT_CHECKOUT_FAILED"] = "EGITCHECKOUT";
+        ErrorCode["GIT_REF_NOT_FOUND"] = "EGITREF";
+        ErrorCode["GIT_NOT_INSTALLED"] = "EGITNOTFOUND";
+        ErrorCode["PARSE_ERROR"] = "EPARSE";
+        ErrorCode["JSON_PARSE_ERROR"] = "EJSONPARSE";
+        ErrorCode["YAML_PARSE_ERROR"] = "EYAMLPARSE";
+        ErrorCode["INVALID_SPECIFIER"] = "EINVALIDSPEC";
+        ErrorCode["MANIFEST_NOT_FOUND"] = "EMANIFEST";
+        ErrorCode["LOCKFILE_NOT_FOUND"] = "ELOCKFILE";
+        ErrorCode["LOCKFILE_OUTDATED"] = "ELOCKOUTDATED";
+        ErrorCode["MANIFEST_EXISTS"] = "EMANIFESTEXISTS";
+        ErrorCode["NETWORK_ERROR"] = "ENETWORK";
+        ErrorCode["REPO_NOT_FOUND"] = "EREPONOTFOUND";
+        ErrorCode["UNKNOWN_ERROR"] = "EUNKNOWN";
+        ErrorCode["NOT_IMPLEMENTED"] = "ENOTIMPL";
+        ErrorCode["VALIDATION_ERROR"] = "EVALIDATION";
+        ErrorCode["SKILL_NOT_FOUND"] = "ESKILLNOTFOUND";
+        ErrorCode["SKILL_EXISTS"] = "ESKILLEXISTS";
+        return ErrorCode;
+    }({});
+    class SpmError extends Error {
+        code;
+        cause;
+        context;
+        constructor(options){
+            super(options.message);
+            this.code = options.code;
+            this.cause = options.cause;
+            this.context = options.context ?? {};
+            this.name = 'SpmError';
+            if (Error.captureStackTrace) Error.captureStackTrace(this, SpmError);
+        }
+        toString() {
+            let result = `${this.code}: ${this.message}`;
+            if (this.cause) result += `\n  Caused by: ${this.cause.message}`;
+            return result;
+        }
+        toJSON() {
+            return {
+                name: this.name,
+                code: this.code,
+                message: this.message,
+                context: this.context,
+                cause: this.cause ? {
+                    name: this.cause.name,
+                    message: this.cause.message
+                } : void 0,
+                stack: this.stack
+            };
+        }
+    }
+    class FileSystemError extends SpmError {
+        operation;
+        path;
+        constructor(options){
+            const message = options.message ?? `${options.operation} failed for ${options.path}`;
+            super({
+                code: options.code,
+                message,
+                cause: options.cause,
+                context: {
+                    operation: options.operation,
+                    path: options.path
+                }
+            });
+            this.operation = options.operation;
+            this.path = options.path;
+            this.name = 'FileSystemError';
+        }
+    }
+    class GitError extends SpmError {
+        operation;
+        repoUrl;
+        ref;
+        constructor(options){
+            const message = options.message ?? `git ${options.operation} failed${options.repoUrl ? ` for ${options.repoUrl}` : ''}`;
+            super({
+                code: options.code,
+                message,
+                cause: options.cause,
+                context: {
+                    operation: options.operation,
+                    repoUrl: options.repoUrl,
+                    ref: options.ref
+                }
+            });
+            this.operation = options.operation;
+            this.repoUrl = options.repoUrl;
+            this.ref = options.ref;
+            this.name = 'GitError';
+        }
+    }
+    class ParseError extends SpmError {
+        filePath;
+        content;
+        constructor(options){
+            super({
+                code: options.code,
+                message: options.message,
+                cause: options.cause,
+                context: {
+                    filePath: options.filePath,
+                    contentSnippet: options.content?.slice(0, 200)
+                }
+            });
+            this.filePath = options.filePath;
+            this.content = options.content;
+            this.name = 'ParseError';
+        }
+    }
+    class ManifestError extends SpmError {
+        filePath;
+        constructor(options){
+            const defaultMessages = {
+                [codes_ErrorCode.MANIFEST_NOT_FOUND]: `Manifest not found: ${options.filePath}`,
+                [codes_ErrorCode.LOCKFILE_NOT_FOUND]: `Lockfile not found: ${options.filePath}`,
+                [codes_ErrorCode.LOCKFILE_OUTDATED]: `Lockfile is out of date: ${options.filePath}`,
+                [codes_ErrorCode.MANIFEST_EXISTS]: `Manifest already exists: ${options.filePath}`
+            };
+            const message = options.message ?? defaultMessages[options.code] ?? `Manifest error: ${options.filePath}`;
+            super({
+                code: options.code,
+                message,
+                cause: options.cause,
+                context: {
+                    filePath: options.filePath
+                }
+            });
+            this.filePath = options.filePath;
+            this.name = 'ManifestError';
+        }
+    }
+    function convertNodeError(error, context) {
+        switch(error.code){
+            case 'ENOENT':
+                return new FileSystemError({
+                    code: codes_ErrorCode.FILE_NOT_FOUND,
+                    operation: context.operation,
+                    path: context.path,
+                    cause: error
+                });
+            case 'EACCES':
+            case 'EPERM':
+                return new FileSystemError({
+                    code: codes_ErrorCode.PERMISSION_DENIED,
+                    operation: context.operation,
+                    path: context.path,
+                    cause: error
+                });
+            case 'EEXIST':
+                return new FileSystemError({
+                    code: codes_ErrorCode.FILE_EXISTS,
+                    operation: context.operation,
+                    path: context.path,
+                    cause: error
+                });
+            case 'ENOTDIR':
+                return new FileSystemError({
+                    code: codes_ErrorCode.FS_ERROR,
+                    operation: context.operation,
+                    path: context.path,
+                    message: `Not a directory: ${context.path}`,
+                    cause: error
+                });
+            case 'EISDIR':
+                return new FileSystemError({
+                    code: codes_ErrorCode.FS_ERROR,
+                    operation: context.operation,
+                    path: context.path,
+                    message: `Is a directory: ${context.path}`,
+                    cause: error
+                });
+            default:
+                return new FileSystemError({
+                    code: codes_ErrorCode.FS_ERROR,
+                    operation: context.operation,
+                    path: context.path,
+                    message: error.message,
+                    cause: error
+                });
+        }
+    }
     async function readSkillsLock(rootDir) {
         const filePath = external_node_path_namespaceObject.join(rootDir, 'skills-lock.yaml');
         try {
             const raw = await (0, promises_namespaceObject.readFile)(filePath, 'utf8');
-            return dist.parse(raw);
+            try {
+                return dist.parse(raw);
+            } catch (parseError) {
+                throw new ParseError({
+                    code: codes_ErrorCode.YAML_PARSE_ERROR,
+                    filePath,
+                    content: raw,
+                    message: `Failed to parse skills-lock.yaml: ${parseError.message}`,
+                    cause: parseError
+                });
+            }
         } catch (error) {
             if ('ENOENT' === error.code) return null;
-            throw error;
+            if (error instanceof ParseError) throw error;
+            throw convertNodeError(error, {
+                operation: 'read',
+                path: filePath
+            });
         }
     }
     async function readSkillsManifest(rootDir) {
         const filePath = external_node_path_namespaceObject.join(rootDir, 'skills.json');
         try {
             const raw = await (0, promises_namespaceObject.readFile)(filePath, 'utf8');
-            const json = JSON.parse(raw);
-            return {
-                installDir: json.installDir ?? '.agents/skills',
-                linkTargets: json.linkTargets ?? [],
-                skills: json.skills ?? {}
-            };
+            try {
+                const json = JSON.parse(raw);
+                return {
+                    installDir: json.installDir ?? '.agents/skills',
+                    linkTargets: json.linkTargets ?? [],
+                    skills: json.skills ?? {}
+                };
+            } catch (parseError) {
+                throw new ParseError({
+                    code: codes_ErrorCode.JSON_PARSE_ERROR,
+                    filePath,
+                    content: raw,
+                    message: `Failed to parse skills.json: ${parseError.message}`,
+                    cause: parseError
+                });
+            }
         } catch (error) {
             if ('ENOENT' === error.code) return null;
-            throw error;
+            if (error instanceof ParseError) throw error;
+            throw convertNodeError(error, {
+                operation: 'read',
+                path: filePath
+            });
         }
     }
     function parseSpecifier(specifier) {
         const firstHashIndex = specifier.indexOf('#');
         const secondHashIndex = firstHashIndex >= 0 ? specifier.indexOf('#', firstHashIndex + 1) : -1;
-        if (secondHashIndex >= 0) throw new Error('Invalid specifier: multiple # fragments are not supported');
+        if (secondHashIndex >= 0) throw new ParseError({
+            code: codes_ErrorCode.INVALID_SPECIFIER,
+            message: 'Invalid specifier: multiple # fragments are not supported',
+            content: specifier
+        });
         const hashIndex = firstHashIndex;
         const sourcePart = hashIndex >= 0 ? specifier.slice(0, hashIndex) : specifier;
         const fragment = hashIndex >= 0 ? specifier.slice(hashIndex + 1) : '';
-        if (!sourcePart) throw new Error('Specifier source is required');
+        if (!sourcePart) throw new ParseError({
+            code: codes_ErrorCode.INVALID_SPECIFIER,
+            message: 'Specifier source is required',
+            content: specifier
+        });
         if (!fragment) return {
             sourcePart,
             ref: null,
@@ -6629,7 +6857,18 @@ var __webpack_exports__ = {};
         };
     }
     function normalizeSpecifier(specifier) {
-        const parsed = parseSpecifier(specifier);
+        let parsed;
+        try {
+            parsed = parseSpecifier(specifier);
+        } catch (error) {
+            if (error instanceof ParseError) throw error;
+            throw new ParseError({
+                code: codes_ErrorCode.INVALID_SPECIFIER,
+                message: `Invalid specifier: ${error.message}`,
+                content: specifier,
+                cause: error
+            });
+        }
         const type = parsed.sourcePart.startsWith('file:') ? 'file' : parsed.sourcePart.startsWith('npm:') ? 'npm' : 'git';
         const skillPath = parsed.path || '/';
         const skillName = external_node_path_namespaceObject.posix.basename(skillPath);
@@ -6696,14 +6935,32 @@ var __webpack_exports__ = {};
         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}`);
+        throw new GitError({
+            code: codes_ErrorCode.GIT_REF_NOT_FOUND,
+            operation: 'resolve-ref',
+            repoUrl: url,
+            ref: target,
+            message: `Unable to resolve git ref "${target}" for ${url}`
+        });
     }
-    async function resolveLockEntry(cwd, specifier) {
-        const normalized = normalizeSpecifier(specifier);
+    async function resolveLockEntry(cwd, specifier, skillName) {
+        let normalized;
+        try {
+            normalized = normalizeSpecifier(specifier);
+        } catch (error) {
+            if (error instanceof ParseError) throw error;
+            throw new ParseError({
+                code: codes_ErrorCode.INVALID_SPECIFIER,
+                message: `Failed to parse specifier "${specifier}": ${error.message}`,
+                content: specifier,
+                cause: error
+            });
+        }
+        const finalSkillName = skillName || normalized.skillName;
         if ('file' === normalized.type) {
             const sourceRoot = external_node_path_namespaceObject.resolve(cwd, normalized.source.slice(5));
             return {
-                skillName: normalized.skillName,
+                skillName: finalSkillName,
                 entry: {
                     specifier: normalized.normalized,
                     resolution: {
@@ -6717,7 +6974,7 @@ var __webpack_exports__ = {};
         if ('git' === normalized.type) {
             const commit = await resolveGitCommit(normalized.source, normalized.ref);
             return {
-                skillName: normalized.skillName,
+                skillName: finalSkillName,
                 entry: {
                     specifier: normalized.normalized,
                     resolution: {
@@ -6730,14 +6987,21 @@ var __webpack_exports__ = {};
                 }
             };
         }
-        throw new Error(`Unsupported specifier type in 0.1.0 core flow: ${normalized.type}`);
+        throw new ParseError({
+            code: codes_ErrorCode.INVALID_SPECIFIER,
+            message: `Unsupported specifier type in 0.1.0 core flow: ${normalized.type}`,
+            content: specifier
+        });
     }
-    async function syncSkillsLock(cwd, manifest, existingLock) {
-        const nextSkills = {};
-        for (const specifier of Object.values(manifest.skills)){
-            const { skillName, entry } = await resolveLockEntry(cwd, specifier);
-            nextSkills[skillName] = entry;
-        }
+    async function syncSkillsLock(cwd, manifest, _existingLock) {
+        const entries = await Promise.all(Object.entries(manifest.skills).map(async ([skillName, specifier])=>{
+            const { skillName: resolvedName, entry } = await resolveLockEntry(cwd, specifier, skillName);
+            return [
+                resolvedName,
+                entry
+            ];
+        }));
+        const nextSkills = Object.fromEntries(entries);
         return {
             lockfileVersion: '0.1',
             installDir: manifest.installDir ?? '.agents/skills',
@@ -6747,7 +7011,14 @@ var __webpack_exports__ = {};
     }
     async function writeSkillsLock(rootDir, lockfile) {
         const filePath = external_node_path_namespaceObject.join(rootDir, 'skills-lock.yaml');
-        await (0, promises_namespaceObject.writeFile)(filePath, dist.stringify(lockfile), 'utf8');
+        try {
+            await (0, promises_namespaceObject.writeFile)(filePath, dist.stringify(lockfile), 'utf8');
+        } catch (error) {
+            throw convertNodeError(error, {
+                operation: 'write',
+                path: filePath
+            });
+        }
     }
     (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.execFile);
     new Set([
@@ -6757,6 +7028,46 @@ var __webpack_exports__ = {};
         'build',
         '__pycache__'
     ]);
+    function parseForComparison(specifier) {
+        const parsed = parseSpecifier(specifier);
+        return {
+            sourcePart: parsed.sourcePart,
+            ref: parsed.ref,
+            path: parsed.path || '/'
+        };
+    }
+    function isSpecifierCompatible(manifestSpecifier, lockSpecifier) {
+        const manifest = parseForComparison(manifestSpecifier);
+        const lock = parseForComparison(lockSpecifier);
+        if (manifest.sourcePart !== lock.sourcePart) return false;
+        if (manifest.path !== lock.path) return false;
+        if (null === manifest.ref) return true;
+        return manifest.ref === lock.ref;
+    }
+    function normalizeInstallDir(dir) {
+        return dir ?? '.agents/skills';
+    }
+    function normalizeLinkTargets(targets) {
+        return targets ?? [];
+    }
+    function arraysEqual(a, b) {
+        if (a.length !== b.length) return false;
+        return a.every((val, i)=>val === b[i]);
+    }
+    function isLockInSync(manifest, lock) {
+        if (!lock) return false;
+        if (normalizeInstallDir(manifest.installDir) !== normalizeInstallDir(lock.installDir)) return false;
+        if (!arraysEqual(normalizeLinkTargets(manifest.linkTargets), normalizeLinkTargets(lock.linkTargets))) return false;
+        const manifestSkills = Object.entries(manifest.skills);
+        const lockSkillNames = Object.keys(lock.skills);
+        if (manifestSkills.length !== lockSkillNames.length) return false;
+        for (const [name, specifier] of manifestSkills){
+            const lockEntry = lock.skills[name];
+            if (!lockEntry) return false;
+            if (!isSpecifierCompatible(specifier, lockEntry.specifier)) return false;
+        }
+        return true;
+    }
     async function ensureDir(dirPath) {
         await (0, promises_namespaceObject.mkdir)(dirPath, {
             recursive: true
@@ -6772,12 +7083,6 @@ var __webpack_exports__ = {};
     async function writeJson(filePath, value) {
         await (0, promises_namespaceObject.writeFile)(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
     }
-    async function linkSkill(rootDir, installDir, linkTarget, skillName) {
-        const absoluteTarget = external_node_path_namespaceObject.join(rootDir, installDir, skillName);
-        const absoluteLink = external_node_path_namespaceObject.join(rootDir, linkTarget, skillName);
-        await ensureDir(external_node_path_namespaceObject.dirname(absoluteLink));
-        await replaceSymlink(absoluteTarget, absoluteLink);
-    }
     async function readInstallState(rootDir) {
         const filePath = external_node_path_namespaceObject.join(rootDir, '.agents/skills/.skills-pm-install-state.json');
         try {
@@ -6792,6 +7097,12 @@ var __webpack_exports__ = {};
         const filePath = external_node_path_namespaceObject.join(dirPath, '.skills-pm-install-state.json');
         await writeJson(filePath, value);
     }
+    async function linkSkill(rootDir, installDir, linkTarget, skillName) {
+        const absoluteTarget = external_node_path_namespaceObject.join(rootDir, installDir, skillName);
+        const absoluteLink = external_node_path_namespaceObject.join(rootDir, linkTarget, skillName);
+        await ensureDir(external_node_path_namespaceObject.dirname(absoluteLink));
+        await replaceSymlink(absoluteTarget, absoluteLink);
+    }
     async function materializeLocalSkill(rootDir, skillName, sourceRoot, sourcePath, installDir) {
         const relativeSkillPath = sourcePath.replace(/^\//, '');
         const absoluteSkillPath = external_node_path_namespaceObject.join(sourceRoot, relativeSkillPath);
@@ -6817,14 +7128,24 @@ 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
-        });
+        try {
+            await materializeGitSkill_execFileAsync('git', [
+                'checkout',
+                commit
+            ], {
+                cwd: checkoutRoot
+            });
+        } catch (error) {
+            throw new GitError({
+                code: codes_ErrorCode.GIT_CHECKOUT_FAILED,
+                operation: 'checkout',
+                ref: commit,
+                message: `Failed to checkout commit ${commit}`,
+                cause: error
+            });
+        }
     }
-    async function fetchCommitFallback(checkoutRoot, commit) {
+    async function fetchCommitFallback(checkoutRoot, commit, _repoUrl) {
         try {
             await materializeGitSkill_execFileAsync('git', [
                 'fetch',
@@ -6867,18 +7188,33 @@ var __webpack_exports__ = {};
     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 {
-            await materializeGitSkill_execFileAsync('git', [
-                'clone',
-                '--depth',
-                '1',
-                repoUrl,
-                checkoutRoot
-            ]);
+            try {
+                await materializeGitSkill_execFileAsync('git', [
+                    'clone',
+                    '--depth',
+                    '1',
+                    repoUrl,
+                    checkoutRoot
+                ]);
+            } catch (error) {
+                throw new GitError({
+                    code: codes_ErrorCode.GIT_CLONE_FAILED,
+                    operation: 'clone',
+                    repoUrl,
+                    message: `Failed to clone repository ${repoUrl}`,
+                    cause: error
+                });
+            }
             if (commit && 'HEAD' !== commit) try {
                 await checkoutCommit(checkoutRoot, commit);
-            } catch  {
-                await fetchCommitFallback(checkoutRoot, commit);
-                await checkoutCommit(checkoutRoot, commit);
+            } catch (checkoutError) {
+                if (checkoutError instanceof GitError) try {
+                    await fetchCommitFallback(checkoutRoot, commit, repoUrl);
+                    await checkoutCommit(checkoutRoot, commit);
+                } catch  {
+                    throw checkoutError;
+                }
+                else throw checkoutError;
             }
             const skillDocPath = external_node_path_namespaceObject.join(checkoutRoot, sourcePath.replace(/^\//, ''), 'SKILL.md');
             await (0, promises_namespaceObject.readFile)(skillDocPath, 'utf8');
@@ -6979,28 +7315,41 @@ var __webpack_exports__ = {};
             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);
+    async function installCommand(options) {
+        const manifest = await readSkillsManifest(options.cwd);
+        if (!manifest) throw new ManifestError({
+            code: codes_ErrorCode.MANIFEST_NOT_FOUND,
+            filePath: `${options.cwd}/skills.json`,
+            message: 'No skills.json found in the current directory. Run "spm init" to create one.'
+        });
+        const currentLock = await readSkillsLock(options.cwd);
+        if (options.frozenLockfile) {
+            if (!currentLock) throw new ManifestError({
+                code: codes_ErrorCode.LOCKFILE_NOT_FOUND,
+                filePath: `${options.cwd}/skills-lock.yaml`,
+                message: 'Lockfile is required in frozen mode but none was found. Run "spm install" first.'
+            });
+            if (!isLockInSync(manifest, currentLock)) throw new ManifestError({
+                code: codes_ErrorCode.LOCKFILE_OUTDATED,
+                filePath: `${options.cwd}/skills-lock.yaml`,
+                message: 'Lockfile is out of sync with manifest. Run install without --frozen-lockfile to update.'
+            });
+            await fetchSkillsFromLock(options.cwd, manifest, currentLock);
+            await linkSkillsFromLock(options.cwd, manifest, currentLock);
+            return {
+                status: 'installed',
+                installed: Object.keys(currentLock.skills)
+            };
+        }
+        const lockfile = await syncSkillsLock(options.cwd, manifest, currentLock);
+        await fetchSkillsFromLock(options.cwd, manifest, lockfile);
+        await linkSkillsFromLock(options.cwd, manifest, lockfile);
+        await writeSkillsLock(options.cwd, lockfile);
         return {
             status: 'installed',
             installed: Object.keys(lockfile.skills)
         };
     }
-    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;

package/dist/index.mjs

@@ -1,9 +1,9 @@
 import { cp, lstat, mkdir, mkdtemp as promises_mkdtemp, readFile as promises_readFile, readdir as promises_readdir, rm, symlink, writeFile as promises_writeFile } from "node:fs/promises";
 import node_path_0 from "node:path";
-import { createHash } from "node:crypto";
-import { tmpdir as external_node_os_tmpdir } from "node:os";
 import { execFile } from "node:child_process";
+import { tmpdir as external_node_os_tmpdir } from "node:os";
 import { promisify, styleText } from "node:util";
+import { createHash } from "node:crypto";
 import node_process from "node:process";
 import "node:readline";
 import "node:tty";
@@ -6555,39 +6555,267 @@ new RegExp(`(?:\\${ke}(?<code>\\d+)m|\\${Se}(?<uri>.*)${Ce})`, "y");
 dist_I("\u2500", "-"), dist_I("\u2501", "="), dist_I("\u2588", "#");
 styleText("gray", dist_h);
 const dist = __webpack_require__("../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/index.js");
+var package_namespaceObject = {
+    rE: "0.3.0"
+};
+var codes_ErrorCode = /*#__PURE__*/ function(ErrorCode) {
+    ErrorCode["FILE_NOT_FOUND"] = "ENOENT";
+    ErrorCode["PERMISSION_DENIED"] = "EACCES";
+    ErrorCode["FILE_EXISTS"] = "EEXIST";
+    ErrorCode["FS_ERROR"] = "EFS";
+    ErrorCode["GIT_CLONE_FAILED"] = "EGITCLONE";
+    ErrorCode["GIT_FETCH_FAILED"] = "EGITFETCH";
+    ErrorCode["GIT_CHECKOUT_FAILED"] = "EGITCHECKOUT";
+    ErrorCode["GIT_REF_NOT_FOUND"] = "EGITREF";
+    ErrorCode["GIT_NOT_INSTALLED"] = "EGITNOTFOUND";
+    ErrorCode["PARSE_ERROR"] = "EPARSE";
+    ErrorCode["JSON_PARSE_ERROR"] = "EJSONPARSE";
+    ErrorCode["YAML_PARSE_ERROR"] = "EYAMLPARSE";
+    ErrorCode["INVALID_SPECIFIER"] = "EINVALIDSPEC";
+    ErrorCode["MANIFEST_NOT_FOUND"] = "EMANIFEST";
+    ErrorCode["LOCKFILE_NOT_FOUND"] = "ELOCKFILE";
+    ErrorCode["LOCKFILE_OUTDATED"] = "ELOCKOUTDATED";
+    ErrorCode["MANIFEST_EXISTS"] = "EMANIFESTEXISTS";
+    ErrorCode["NETWORK_ERROR"] = "ENETWORK";
+    ErrorCode["REPO_NOT_FOUND"] = "EREPONOTFOUND";
+    ErrorCode["UNKNOWN_ERROR"] = "EUNKNOWN";
+    ErrorCode["NOT_IMPLEMENTED"] = "ENOTIMPL";
+    ErrorCode["VALIDATION_ERROR"] = "EVALIDATION";
+    ErrorCode["SKILL_NOT_FOUND"] = "ESKILLNOTFOUND";
+    ErrorCode["SKILL_EXISTS"] = "ESKILLEXISTS";
+    return ErrorCode;
+}({});
+class SpmError extends Error {
+    code;
+    cause;
+    context;
+    constructor(options){
+        super(options.message);
+        this.code = options.code;
+        this.cause = options.cause;
+        this.context = options.context ?? {};
+        this.name = 'SpmError';
+        if (Error.captureStackTrace) Error.captureStackTrace(this, SpmError);
+    }
+    toString() {
+        let result = `${this.code}: ${this.message}`;
+        if (this.cause) result += `\n  Caused by: ${this.cause.message}`;
+        return result;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            context: this.context,
+            cause: this.cause ? {
+                name: this.cause.name,
+                message: this.cause.message
+            } : void 0,
+            stack: this.stack
+        };
+    }
+}
+class FileSystemError extends SpmError {
+    operation;
+    path;
+    constructor(options){
+        const message = options.message ?? `${options.operation} failed for ${options.path}`;
+        super({
+            code: options.code,
+            message,
+            cause: options.cause,
+            context: {
+                operation: options.operation,
+                path: options.path
+            }
+        });
+        this.operation = options.operation;
+        this.path = options.path;
+        this.name = 'FileSystemError';
+    }
+}
+class GitError extends SpmError {
+    operation;
+    repoUrl;
+    ref;
+    constructor(options){
+        const message = options.message ?? `git ${options.operation} failed${options.repoUrl ? ` for ${options.repoUrl}` : ''}`;
+        super({
+            code: options.code,
+            message,
+            cause: options.cause,
+            context: {
+                operation: options.operation,
+                repoUrl: options.repoUrl,
+                ref: options.ref
+            }
+        });
+        this.operation = options.operation;
+        this.repoUrl = options.repoUrl;
+        this.ref = options.ref;
+        this.name = 'GitError';
+    }
+}
+class ParseError extends SpmError {
+    filePath;
+    content;
+    constructor(options){
+        super({
+            code: options.code,
+            message: options.message,
+            cause: options.cause,
+            context: {
+                filePath: options.filePath,
+                contentSnippet: options.content?.slice(0, 200)
+            }
+        });
+        this.filePath = options.filePath;
+        this.content = options.content;
+        this.name = 'ParseError';
+    }
+}
+class ManifestError extends SpmError {
+    filePath;
+    constructor(options){
+        const defaultMessages = {
+            [codes_ErrorCode.MANIFEST_NOT_FOUND]: `Manifest not found: ${options.filePath}`,
+            [codes_ErrorCode.LOCKFILE_NOT_FOUND]: `Lockfile not found: ${options.filePath}`,
+            [codes_ErrorCode.LOCKFILE_OUTDATED]: `Lockfile is out of date: ${options.filePath}`,
+            [codes_ErrorCode.MANIFEST_EXISTS]: `Manifest already exists: ${options.filePath}`
+        };
+        const message = options.message ?? defaultMessages[options.code] ?? `Manifest error: ${options.filePath}`;
+        super({
+            code: options.code,
+            message,
+            cause: options.cause,
+            context: {
+                filePath: options.filePath
+            }
+        });
+        this.filePath = options.filePath;
+        this.name = 'ManifestError';
+    }
+}
+function convertNodeError(error, context) {
+    switch(error.code){
+        case 'ENOENT':
+            return new FileSystemError({
+                code: codes_ErrorCode.FILE_NOT_FOUND,
+                operation: context.operation,
+                path: context.path,
+                cause: error
+            });
+        case 'EACCES':
+        case 'EPERM':
+            return new FileSystemError({
+                code: codes_ErrorCode.PERMISSION_DENIED,
+                operation: context.operation,
+                path: context.path,
+                cause: error
+            });
+        case 'EEXIST':
+            return new FileSystemError({
+                code: codes_ErrorCode.FILE_EXISTS,
+                operation: context.operation,
+                path: context.path,
+                cause: error
+            });
+        case 'ENOTDIR':
+            return new FileSystemError({
+                code: codes_ErrorCode.FS_ERROR,
+                operation: context.operation,
+                path: context.path,
+                message: `Not a directory: ${context.path}`,
+                cause: error
+            });
+        case 'EISDIR':
+            return new FileSystemError({
+                code: codes_ErrorCode.FS_ERROR,
+                operation: context.operation,
+                path: context.path,
+                message: `Is a directory: ${context.path}`,
+                cause: error
+            });
+        default:
+            return new FileSystemError({
+                code: codes_ErrorCode.FS_ERROR,
+                operation: context.operation,
+                path: context.path,
+                message: error.message,
+                cause: error
+            });
+    }
+}
 async function readSkillsLock(rootDir) {
     const filePath = node_path_0.join(rootDir, 'skills-lock.yaml');
     try {
         const raw = await promises_readFile(filePath, 'utf8');
-        return dist.parse(raw);
+        try {
+            return dist.parse(raw);
+        } catch (parseError) {
+            throw new ParseError({
+                code: codes_ErrorCode.YAML_PARSE_ERROR,
+                filePath,
+                content: raw,
+                message: `Failed to parse skills-lock.yaml: ${parseError.message}`,
+                cause: parseError
+            });
+        }
     } catch (error) {
         if ('ENOENT' === error.code) return null;
-        throw error;
+        if (error instanceof ParseError) throw error;
+        throw convertNodeError(error, {
+            operation: 'read',
+            path: filePath
+        });
     }
 }
 async function readSkillsManifest(rootDir) {
     const filePath = node_path_0.join(rootDir, 'skills.json');
     try {
         const raw = await promises_readFile(filePath, 'utf8');
-        const json = JSON.parse(raw);
-        return {
-            installDir: json.installDir ?? '.agents/skills',
-            linkTargets: json.linkTargets ?? [],
-            skills: json.skills ?? {}
-        };
+        try {
+            const json = JSON.parse(raw);
+            return {
+                installDir: json.installDir ?? '.agents/skills',
+                linkTargets: json.linkTargets ?? [],
+                skills: json.skills ?? {}
+            };
+        } catch (parseError) {
+            throw new ParseError({
+                code: codes_ErrorCode.JSON_PARSE_ERROR,
+                filePath,
+                content: raw,
+                message: `Failed to parse skills.json: ${parseError.message}`,
+                cause: parseError
+            });
+        }
     } catch (error) {
         if ('ENOENT' === error.code) return null;
-        throw error;
+        if (error instanceof ParseError) throw error;
+        throw convertNodeError(error, {
+            operation: 'read',
+            path: filePath
+        });
     }
 }
 function parseSpecifier(specifier) {
     const firstHashIndex = specifier.indexOf('#');
     const secondHashIndex = firstHashIndex >= 0 ? specifier.indexOf('#', firstHashIndex + 1) : -1;
-    if (secondHashIndex >= 0) throw new Error('Invalid specifier: multiple # fragments are not supported');
+    if (secondHashIndex >= 0) throw new ParseError({
+        code: codes_ErrorCode.INVALID_SPECIFIER,
+        message: 'Invalid specifier: multiple # fragments are not supported',
+        content: specifier
+    });
     const hashIndex = firstHashIndex;
     const sourcePart = hashIndex >= 0 ? specifier.slice(0, hashIndex) : specifier;
     const fragment = hashIndex >= 0 ? specifier.slice(hashIndex + 1) : '';
-    if (!sourcePart) throw new Error('Specifier source is required');
+    if (!sourcePart) throw new ParseError({
+        code: codes_ErrorCode.INVALID_SPECIFIER,
+        message: 'Specifier source is required',
+        content: specifier
+    });
     if (!fragment) return {
         sourcePart,
         ref: null,
@@ -6610,7 +6838,18 @@ function parseSpecifier(specifier) {
     };
 }
 function normalizeSpecifier(specifier) {
-    const parsed = parseSpecifier(specifier);
+    let parsed;
+    try {
+        parsed = parseSpecifier(specifier);
+    } catch (error) {
+        if (error instanceof ParseError) throw error;
+        throw new ParseError({
+            code: codes_ErrorCode.INVALID_SPECIFIER,
+            message: `Invalid specifier: ${error.message}`,
+            content: specifier,
+            cause: error
+        });
+    }
     const type = parsed.sourcePart.startsWith('file:') ? 'file' : parsed.sourcePart.startsWith('npm:') ? 'npm' : 'git';
     const skillPath = parsed.path || '/';
     const skillName = node_path_0.posix.basename(skillPath);
@@ -6677,14 +6916,32 @@ async function resolveGitCommit(url, ref) {
     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}`);
+    throw new GitError({
+        code: codes_ErrorCode.GIT_REF_NOT_FOUND,
+        operation: 'resolve-ref',
+        repoUrl: url,
+        ref: target,
+        message: `Unable to resolve git ref "${target}" for ${url}`
+    });
 }
-async function resolveLockEntry(cwd, specifier) {
-    const normalized = normalizeSpecifier(specifier);
+async function resolveLockEntry(cwd, specifier, skillName) {
+    let normalized;
+    try {
+        normalized = normalizeSpecifier(specifier);
+    } catch (error) {
+        if (error instanceof ParseError) throw error;
+        throw new ParseError({
+            code: codes_ErrorCode.INVALID_SPECIFIER,
+            message: `Failed to parse specifier "${specifier}": ${error.message}`,
+            content: specifier,
+            cause: error
+        });
+    }
+    const finalSkillName = skillName || normalized.skillName;
     if ('file' === normalized.type) {
         const sourceRoot = node_path_0.resolve(cwd, normalized.source.slice(5));
         return {
-            skillName: normalized.skillName,
+            skillName: finalSkillName,
             entry: {
                 specifier: normalized.normalized,
                 resolution: {
@@ -6698,7 +6955,7 @@ async function resolveLockEntry(cwd, specifier) {
     if ('git' === normalized.type) {
         const commit = await resolveGitCommit(normalized.source, normalized.ref);
         return {
-            skillName: normalized.skillName,
+            skillName: finalSkillName,
             entry: {
                 specifier: normalized.normalized,
                 resolution: {
@@ -6711,14 +6968,21 @@ async function resolveLockEntry(cwd, specifier) {
             }
         };
     }
-    throw new Error(`Unsupported specifier type in 0.1.0 core flow: ${normalized.type}`);
+    throw new ParseError({
+        code: codes_ErrorCode.INVALID_SPECIFIER,
+        message: `Unsupported specifier type in 0.1.0 core flow: ${normalized.type}`,
+        content: specifier
+    });
 }
-async function syncSkillsLock(cwd, manifest, existingLock) {
-    const nextSkills = {};
-    for (const specifier of Object.values(manifest.skills)){
-        const { skillName, entry } = await resolveLockEntry(cwd, specifier);
-        nextSkills[skillName] = entry;
-    }
+async function syncSkillsLock(cwd, manifest, _existingLock) {
+    const entries = await Promise.all(Object.entries(manifest.skills).map(async ([skillName, specifier])=>{
+        const { skillName: resolvedName, entry } = await resolveLockEntry(cwd, specifier, skillName);
+        return [
+            resolvedName,
+            entry
+        ];
+    }));
+    const nextSkills = Object.fromEntries(entries);
     return {
         lockfileVersion: '0.1',
         installDir: manifest.installDir ?? '.agents/skills',
@@ -6728,7 +6992,14 @@ async function syncSkillsLock(cwd, manifest, existingLock) {
 }
 async function writeSkillsLock(rootDir, lockfile) {
     const filePath = node_path_0.join(rootDir, 'skills-lock.yaml');
-    await promises_writeFile(filePath, dist.stringify(lockfile), 'utf8');
+    try {
+        await promises_writeFile(filePath, dist.stringify(lockfile), 'utf8');
+    } catch (error) {
+        throw convertNodeError(error, {
+            operation: 'write',
+            path: filePath
+        });
+    }
 }
 promisify(execFile);
 new Set([
@@ -6738,6 +7009,46 @@ new Set([
     'build',
     '__pycache__'
 ]);
+function parseForComparison(specifier) {
+    const parsed = parseSpecifier(specifier);
+    return {
+        sourcePart: parsed.sourcePart,
+        ref: parsed.ref,
+        path: parsed.path || '/'
+    };
+}
+function isSpecifierCompatible(manifestSpecifier, lockSpecifier) {
+    const manifest = parseForComparison(manifestSpecifier);
+    const lock = parseForComparison(lockSpecifier);
+    if (manifest.sourcePart !== lock.sourcePart) return false;
+    if (manifest.path !== lock.path) return false;
+    if (null === manifest.ref) return true;
+    return manifest.ref === lock.ref;
+}
+function normalizeInstallDir(dir) {
+    return dir ?? '.agents/skills';
+}
+function normalizeLinkTargets(targets) {
+    return targets ?? [];
+}
+function arraysEqual(a, b) {
+    if (a.length !== b.length) return false;
+    return a.every((val, i)=>val === b[i]);
+}
+function isLockInSync(manifest, lock) {
+    if (!lock) return false;
+    if (normalizeInstallDir(manifest.installDir) !== normalizeInstallDir(lock.installDir)) return false;
+    if (!arraysEqual(normalizeLinkTargets(manifest.linkTargets), normalizeLinkTargets(lock.linkTargets))) return false;
+    const manifestSkills = Object.entries(manifest.skills);
+    const lockSkillNames = Object.keys(lock.skills);
+    if (manifestSkills.length !== lockSkillNames.length) return false;
+    for (const [name, specifier] of manifestSkills){
+        const lockEntry = lock.skills[name];
+        if (!lockEntry) return false;
+        if (!isSpecifierCompatible(specifier, lockEntry.specifier)) return false;
+    }
+    return true;
+}
 async function ensureDir(dirPath) {
     await mkdir(dirPath, {
         recursive: true
@@ -6753,12 +7064,6 @@ async function replaceSymlink(target, linkPath) {
 async function writeJson(filePath, value) {
     await promises_writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
 }
-async function linkSkill(rootDir, installDir, linkTarget, skillName) {
-    const absoluteTarget = node_path_0.join(rootDir, installDir, skillName);
-    const absoluteLink = node_path_0.join(rootDir, linkTarget, skillName);
-    await ensureDir(node_path_0.dirname(absoluteLink));
-    await replaceSymlink(absoluteTarget, absoluteLink);
-}
 async function readInstallState(rootDir) {
     const filePath = node_path_0.join(rootDir, '.agents/skills/.skills-pm-install-state.json');
     try {
@@ -6773,6 +7078,12 @@ async function writeInstallState(rootDir, value) {
     const filePath = node_path_0.join(dirPath, '.skills-pm-install-state.json');
     await writeJson(filePath, value);
 }
+async function linkSkill(rootDir, installDir, linkTarget, skillName) {
+    const absoluteTarget = node_path_0.join(rootDir, installDir, skillName);
+    const absoluteLink = node_path_0.join(rootDir, linkTarget, skillName);
+    await ensureDir(node_path_0.dirname(absoluteLink));
+    await replaceSymlink(absoluteTarget, absoluteLink);
+}
 async function materializeLocalSkill(rootDir, skillName, sourceRoot, sourcePath, installDir) {
     const relativeSkillPath = sourcePath.replace(/^\//, '');
     const absoluteSkillPath = node_path_0.join(sourceRoot, relativeSkillPath);
@@ -6798,14 +7109,24 @@ async function materializeLocalSkill(rootDir, skillName, sourceRoot, sourcePath,
 }
 const materializeGitSkill_execFileAsync = promisify(execFile);
 async function checkoutCommit(checkoutRoot, commit) {
-    await materializeGitSkill_execFileAsync('git', [
-        'checkout',
-        commit
-    ], {
-        cwd: checkoutRoot
-    });
+    try {
+        await materializeGitSkill_execFileAsync('git', [
+            'checkout',
+            commit
+        ], {
+            cwd: checkoutRoot
+        });
+    } catch (error) {
+        throw new GitError({
+            code: codes_ErrorCode.GIT_CHECKOUT_FAILED,
+            operation: 'checkout',
+            ref: commit,
+            message: `Failed to checkout commit ${commit}`,
+            cause: error
+        });
+    }
 }
-async function fetchCommitFallback(checkoutRoot, commit) {
+async function fetchCommitFallback(checkoutRoot, commit, _repoUrl) {
     try {
         await materializeGitSkill_execFileAsync('git', [
             'fetch',
@@ -6848,18 +7169,33 @@ async function fetchCommitFallback(checkoutRoot, commit) {
 async function materializeGitSkill(rootDir, skillName, repoUrl, commit, sourcePath, installDir) {
     const checkoutRoot = await promises_mkdtemp(node_path_0.join(external_node_os_tmpdir(), 'skills-pm-git-checkout-'));
     try {
-        await materializeGitSkill_execFileAsync('git', [
-            'clone',
-            '--depth',
-            '1',
-            repoUrl,
-            checkoutRoot
-        ]);
+        try {
+            await materializeGitSkill_execFileAsync('git', [
+                'clone',
+                '--depth',
+                '1',
+                repoUrl,
+                checkoutRoot
+            ]);
+        } catch (error) {
+            throw new GitError({
+                code: codes_ErrorCode.GIT_CLONE_FAILED,
+                operation: 'clone',
+                repoUrl,
+                message: `Failed to clone repository ${repoUrl}`,
+                cause: error
+            });
+        }
         if (commit && 'HEAD' !== commit) try {
             await checkoutCommit(checkoutRoot, commit);
-        } catch  {
-            await fetchCommitFallback(checkoutRoot, commit);
-            await checkoutCommit(checkoutRoot, commit);
+        } catch (checkoutError) {
+            if (checkoutError instanceof GitError) try {
+                await fetchCommitFallback(checkoutRoot, commit, repoUrl);
+                await checkoutCommit(checkoutRoot, commit);
+            } catch  {
+                throw checkoutError;
+            }
+            else throw checkoutError;
         }
         const skillDocPath = node_path_0.join(checkoutRoot, sourcePath.replace(/^\//, ''), 'SKILL.md');
         await promises_readFile(skillDocPath, 'utf8');
@@ -6960,28 +7296,41 @@ async function linkSkillsFromLock(rootDir, manifest, lockfile) {
         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);
+async function installCommand(options) {
+    const manifest = await readSkillsManifest(options.cwd);
+    if (!manifest) throw new ManifestError({
+        code: codes_ErrorCode.MANIFEST_NOT_FOUND,
+        filePath: `${options.cwd}/skills.json`,
+        message: 'No skills.json found in the current directory. Run "spm init" to create one.'
+    });
+    const currentLock = await readSkillsLock(options.cwd);
+    if (options.frozenLockfile) {
+        if (!currentLock) throw new ManifestError({
+            code: codes_ErrorCode.LOCKFILE_NOT_FOUND,
+            filePath: `${options.cwd}/skills-lock.yaml`,
+            message: 'Lockfile is required in frozen mode but none was found. Run "spm install" first.'
+        });
+        if (!isLockInSync(manifest, currentLock)) throw new ManifestError({
+            code: codes_ErrorCode.LOCKFILE_OUTDATED,
+            filePath: `${options.cwd}/skills-lock.yaml`,
+            message: 'Lockfile is out of sync with manifest. Run install without --frozen-lockfile to update.'
+        });
+        await fetchSkillsFromLock(options.cwd, manifest, currentLock);
+        await linkSkillsFromLock(options.cwd, manifest, currentLock);
+        return {
+            status: 'installed',
+            installed: Object.keys(currentLock.skills)
+        };
+    }
+    const lockfile = await syncSkillsLock(options.cwd, manifest, currentLock);
+    await fetchSkillsFromLock(options.cwd, manifest, lockfile);
+    await linkSkillsFromLock(options.cwd, manifest, lockfile);
+    await writeSkillsLock(options.cwd, lockfile);
     return {
         status: 'installed',
         installed: Object.keys(lockfile.skills)
     };
 }
-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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pnpm-plugin-skills",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "commonjs",
   "repository": {
     "type": "git",
@@ -13,7 +13,7 @@
     "pnpmfile.mjs"
   ],
   "dependencies": {
-    "skills-package-manager": "0.2.0"
+    "skills-package-manager": "0.3.0"
   },
   "devDependencies": {
     "@rslib/core": "^0.20.0",

package/pnpmfile.mjs

@@ -1,4 +1,4 @@
 // pnpm v11
-import { preResolution } from './dist/index.mjs';
+import { preResolution } from './dist/index.mjs'
 
-export const hooks = { preResolution };
+export const hooks = { preResolution }