@cuylabs/agent-capability-pack 0.13.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,67 @@
+# @cuylabs/agent-capability-pack
+
+Distributable capability packs for `@cuylabs/agent-core`.
+
+A capability pack is a single unit that can contribute:
+
+- skills
+- MCP server configurations
+- plugin contributions
+
+This package gives you:
+
+- `defineCapabilityPack()` for inline or package-authored packs
+- `PackRef` + source resolvers for inline, local, npm, URL, and git sources
+- `PackLoader` to register pack content into `agent-core`
+- `MCPSkillBridge` to surface MCP prompts as skills
+
+## Install
+
+```bash
+pnpm add @cuylabs/agent-capability-pack @cuylabs/agent-core
+```
+
+## Quick Start
+
+```ts
+import { emptySkillRegistry } from "@cuylabs/agent-core/skill";
+import { PluginRegistry } from "@cuylabs/agent-core/plugin";
+import { createMCPManager } from "@cuylabs/agent-core/mcp";
+import {
+  PackLoader,
+  defineCapabilityPack,
+  inlinePack,
+  MCPSkillBridge,
+} from "@cuylabs/agent-capability-pack";
+
+const skillRegistry = emptySkillRegistry();
+const pluginRegistry = new PluginRegistry();
+
+const localPack = defineCapabilityPack({
+  id: "demo-pack",
+  name: "Demo Pack",
+  skills: [
+    {
+      name: "demo-skill",
+      description: "Use when the task needs the demo workflow.",
+      body: "# Demo Skill\n\nFollow the demo workflow carefully.",
+    },
+  ],
+});
+
+const loader = new PackLoader({ skillRegistry, pluginRegistry });
+const result = await loader.loadAll([inlinePack(localPack)]);
+
+const mcp = createMCPManager(result.mcpServers);
+await mcp.connect();
+
+const bridge = new MCPSkillBridge(mcp, skillRegistry);
+await bridge.bridge();
+```
+
+## Docs
+
+- [docs/README.md](./docs/README.md)
+- [docs/authoring.md](./docs/authoring.md)
+- [docs/sources.md](./docs/sources.md)
+- [docs/mcp-bridge.md](./docs/mcp-bridge.md)

package/dist/bridge/index.d.ts

@@ -0,0 +1,77 @@
+import { MCPManager } from '@cuylabs/agent-core/mcp';
+import { SkillRegistry } from '@cuylabs/agent-core/skill';
+
+/**
+ * MCPSkillBridge — surfaces MCP server prompts as skills in the SkillRegistry.
+ *
+ * This is the fix for the missing connection between the MCP and skill
+ * subsystems. When an MCP server declares prompts (via `prompts/list`),
+ * those prompts are activated the same way as file-based skills — the agent
+ * calls the `skill` tool, the bridge fetches the prompt from the server and
+ * returns its content as L2 skill content.
+ *
+ * ## How it works
+ *
+ * 1. `bridge()` calls `mcpManager.listPrompts()` to get all prompts from
+ *    connected servers.
+ * 2. Each prompt becomes a `SkillMetadata` entry registered in the
+ *    `SkillRegistry` (L1 — always visible to the agent).
+ * 3. Static prompts (no arguments) are rendered immediately via
+ *    `mcpManager.getPrompt()` and cached as L2 skill content.
+ * 4. Parameterized prompts are converted into metadata-backed skill content
+ *    that lists prompt arguments and usage.
+ *
+ * ## Naming
+ *
+ * Bridged skill names are scoped to their server to avoid collisions:
+ *   `<serverName>:<promptName>`
+ *
+ * If a project or user skill with the same name exists, it wins
+ * (the registry's `register()` respects scope priority).
+ *
+ * ## Usage
+ *
+ * Call `bridge()` AFTER `mcpManager.connect()` and before the agent loop:
+ *
+ * ```ts
+ * await mcpManager.connect()
+ * const bridge = new MCPSkillBridge(mcpManager, skillRegistry)
+ * const result = await bridge.bridge()
+ * // result.bridgedCount — skills registered from MCP prompts
+ * // result.errors       — servers that failed to list prompts
+ * ```
+ */
+
+interface BridgeResult {
+    /** Number of MCP prompts successfully registered or updated as skills. */
+    bridgedCount: number;
+    /**
+     * Non-fatal bridge warnings or errors.
+     * Static prompts may still bridge successfully while returning a fallback warning.
+     */
+    errors: Array<{
+        server: string;
+        error: string;
+    }>;
+}
+/**
+ * Bridges MCP server prompts into the skill registry as first-class skills.
+ *
+ * The bridge is designed to be called once per agent session, after
+ * `mcpManager.connect()` resolves. It is idempotent — calling `bridge()`
+ * multiple times updates previously bridged skills in place.
+ */
+declare class MCPSkillBridge {
+    private readonly mcpManager;
+    private readonly skillRegistry;
+    constructor(mcpManager: MCPManager, skillRegistry: SkillRegistry);
+    /**
+     * Discover all prompts from connected MCP servers and register them as skills.
+     *
+     * @returns Summary of what was bridged and any errors encountered.
+     */
+    bridge(): Promise<BridgeResult>;
+    private buildPromptSkill;
+}
+
+export { type BridgeResult, MCPSkillBridge };

package/dist/bridge/index.js

@@ -0,0 +1,7 @@
+import {
+  MCPSkillBridge
+} from "../chunk-LDYHPSNE.js";
+export {
+  MCPSkillBridge
+};
+//# sourceMappingURL=index.js.map

package/dist/bridge/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-2TICMDUA.js

@@ -0,0 +1,25 @@
+// src/sources/types.ts
+function inlinePack(pack) {
+  return { source: "inline", pack };
+}
+function localPack(path) {
+  return { source: "local", path };
+}
+function npmPack(pkg, options) {
+  return { source: "npm", package: pkg, export: options?.export };
+}
+function urlPack(url) {
+  return { source: "url", url };
+}
+function gitPack(url, ref) {
+  return { source: "git", url, ...ref ? { ref } : {} };
+}
+
+export {
+  inlinePack,
+  localPack,
+  npmPack,
+  urlPack,
+  gitPack
+};
+//# sourceMappingURL=chunk-2TICMDUA.js.map

package/dist/chunk-2TICMDUA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sources/types.ts"],"sourcesContent":["/**\n * PackRef — typed references to capability packs from external sources.\n *\n * A `PackRef` tells the resolver WHERE to get a pack.\n * Every ref resolves to the same `CapabilityPack` shape, regardless of origin.\n *\n * Use the helper constructors below rather than building refs by hand:\n *\n *   inlinePack(pack)           — already-constructed CapabilityPack\n *   localPack(\"./path\")        — directory on disk with a pack.json\n *   npmPack(\"@org/my-pack\")    — npm package exporting a CapabilityPack\n *   urlPack(\"https://...\")     — URL serving a pack JSON manifest\n *   gitPack(\"https://...\")     — Git repository containing a pack\n */\n\nimport type { CapabilityPack } from \"../pack/types.js\";\n\n// ============================================================================\n// PackRef discriminated union\n// ============================================================================\n\n/** A pack that is already constructed — no resolution needed. */\nexport interface InlinePackRef {\n  source: \"inline\";\n  pack: CapabilityPack;\n}\n\n/**\n * A pack stored in a local directory.\n *\n * The directory must contain a `pack.json` manifest. Skills are discovered\n * from a `skills/` subdirectory using the SKILL.md convention. MCP server\n * configs and plugin entry paths are read from `pack.json`.\n */\nexport interface LocalPackRef {\n  source: \"local\";\n  /** Absolute or cwd-relative path to the pack directory. */\n  path: string;\n}\n\n/**\n * A pack published as an npm package.\n *\n * The package must have a default export or a named export that is a\n * `CapabilityPack`. The resolver uses a dynamic `import()`.\n *\n * @example\n * ```ts\n * npmPack(\"@mycompany/agent-pack\")\n * npmPack(\"@mycompany/agent-pack\", { export: \"dataPack\" })\n * ```\n */\nexport interface NpmPackRef {\n  source: \"npm\";\n  /** npm package specifier (e.g. \"@mycompany/agent-pack\" or \"agent-pack@1.2.0\"). */\n  package: string;\n  /**\n   * Named export to use as the pack.\n   *\n   * When omitted, the default export is used.\n   */\n  export?: string;\n}\n\n/**\n * A pack served as JSON at a URL.\n *\n * The URL must return a JSON object matching `CapabilityPack`.\n * Only the pack metadata, skills, and MCP server configs are supported\n * via URL packs — plugin code cannot be loaded from a URL for security.\n */\nexport interface UrlPackRef {\n  source: \"url\";\n  /** HTTPS URL serving the pack JSON. */\n  url: string;\n}\n\n/**\n * A pack stored in a Git repository.\n *\n * The repository root must contain a `pack.json` manifest.\n * The resolver clones (or fetches) the repository to a local cache\n * before reading the pack.\n *\n * Requires `git` to be available on PATH.\n */\nexport interface GitPackRef {\n  source: \"git\";\n  /** Git-cloneable URL (HTTPS or SSH). */\n  url: string;\n  /** Branch, tag, or commit SHA to check out. Defaults to the default branch. */\n  ref?: string;\n}\n\n/** Union of all pack reference types. */\nexport type PackRef =\n  | InlinePackRef\n  | LocalPackRef\n  | NpmPackRef\n  | UrlPackRef\n  | GitPackRef;\n\n// ============================================================================\n// Helper constructors\n// ============================================================================\n\n/** Reference to an already-constructed CapabilityPack. */\nexport function inlinePack(pack: CapabilityPack): InlinePackRef {\n  return { source: \"inline\", pack };\n}\n\n/** Reference to a pack stored in a local directory. */\nexport function localPack(path: string): LocalPackRef {\n  return { source: \"local\", path };\n}\n\n/**\n * Reference to a pack published as an npm package.\n *\n * @param pkg  Package specifier (e.g. `\"@mycompany/agent-pack\"`).\n * @param options.export  Named export to use instead of the default export.\n */\nexport function npmPack(\n  pkg: string,\n  options?: { export?: string },\n): NpmPackRef {\n  return { source: \"npm\", package: pkg, export: options?.export };\n}\n\n/** Reference to a pack served as JSON at a URL. */\nexport function urlPack(url: string): UrlPackRef {\n  return { source: \"url\", url };\n}\n\n/**\n * Reference to a pack in a Git repository.\n *\n * @param url  Git URL (HTTPS or SSH).\n * @param ref  Branch, tag, or commit. Defaults to the default branch.\n */\nexport function gitPack(url: string, ref?: string): GitPackRef {\n  return { source: \"git\", url, ...(ref ? { ref } : {}) };\n}\n"],"mappings":";AA2GO,SAAS,WAAW,MAAqC;AAC9D,SAAO,EAAE,QAAQ,UAAU,KAAK;AAClC;AAGO,SAAS,UAAU,MAA4B;AACpD,SAAO,EAAE,QAAQ,SAAS,KAAK;AACjC;AAQO,SAAS,QACd,KACA,SACY;AACZ,SAAO,EAAE,QAAQ,OAAO,SAAS,KAAK,QAAQ,SAAS,OAAO;AAChE;AAGO,SAAS,QAAQ,KAAyB;AAC/C,SAAO,EAAE,QAAQ,OAAO,IAAI;AAC9B;AAQO,SAAS,QAAQ,KAAa,KAA0B;AAC7D,SAAO,EAAE,QAAQ,OAAO,KAAK,GAAI,MAAM,EAAE,IAAI,IAAI,CAAC,EAAG;AACvD;","names":[]}

package/dist/chunk-5E66GFAI.js

@@ -0,0 +1,290 @@
+// src/pack/types.ts
+var CAPABILITY_PACK_KIND = "agent-capability-pack";
+var CAPABILITY_PACK_SCHEMA_VERSION = 1;
+
+// src/sources/validate.ts
+function validatePackManifest(manifest, source) {
+  if (typeof manifest.id !== "string" || manifest.id.trim() === "") {
+    throw new Error(
+      `Pack manifest at "${source}" is missing a required string "id" field.`
+    );
+  }
+  if (manifest.id.includes(" ")) {
+    throw new Error(
+      `Pack manifest at "${source}" has an invalid "id" \u2014 must not contain spaces (use kebab-case).`
+    );
+  }
+  if (manifest.kind !== void 0 && manifest.kind !== CAPABILITY_PACK_KIND) {
+    throw new Error(
+      `Pack manifest at "${source}" has unsupported "kind" "${String(manifest.kind)}". Expected "${CAPABILITY_PACK_KIND}".`
+    );
+  }
+  if (manifest.schemaVersion !== void 0 && manifest.schemaVersion !== CAPABILITY_PACK_SCHEMA_VERSION) {
+    throw new Error(
+      `Pack manifest at "${source}" has unsupported schemaVersion "${String(manifest.schemaVersion)}". Expected ${CAPABILITY_PACK_SCHEMA_VERSION}.`
+    );
+  }
+}
+function assertNoPluginInUrlPack(manifest, url) {
+  if (manifest.plugin !== void 0) {
+    throw new Error(
+      `Pack from URL "${url}" declares a plugin, which is not allowed. Plugin code can only be loaded from local files or npm packages.`
+    );
+  }
+}
+function normalizePackManifest(pack) {
+  return {
+    kind: pack.kind ?? CAPABILITY_PACK_KIND,
+    schemaVersion: pack.schemaVersion ?? CAPABILITY_PACK_SCHEMA_VERSION,
+    ...pack
+  };
+}
+
+// src/sources/inline-source.ts
+function resolveInlinePack(ref) {
+  return normalizePackManifest(ref.pack);
+}
+
+// src/sources/local-source.ts
+import { readFile } from "fs/promises";
+import { join, resolve } from "path";
+import { loadPluginModule } from "@cuylabs/agent-core/plugin";
+import { discoverSkills, loadSkillContent } from "@cuylabs/agent-core/skill";
+async function resolveLocalPack(ref) {
+  const absPath = resolve(ref.path);
+  const manifest = await readPackJson(absPath);
+  validatePackManifest(manifest, absPath);
+  const skills = await discoverAndInlineSkills(absPath);
+  const plugin = await resolveLocalPlugin(absPath, manifest.plugin);
+  return normalizePackManifest({
+    id: manifest.id,
+    name: manifest.name,
+    description: manifest.description,
+    version: manifest.version,
+    skills,
+    mcpServers: manifest.mcpServers,
+    plugin
+  });
+}
+async function readPackJson(packDir) {
+  const packJsonPath = join(packDir, "pack.json");
+  let raw;
+  try {
+    raw = await readFile(packJsonPath, "utf-8");
+  } catch {
+    throw new Error(
+      `Cannot read pack.json at ${packJsonPath}. Ensure the directory is a valid capability pack.`
+    );
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(`pack.json at ${packJsonPath} contains invalid JSON.`);
+  }
+}
+async function discoverAndInlineSkills(packDir) {
+  const skillsDir = join(packDir, "skills");
+  const discovery = await discoverSkills(packDir, {
+    roots: [skillsDir],
+    // One extra level to handle skills/my-skill/SKILL.md.
+    maxScanDepth: 3,
+    // Disable external directory scanning — we only want this pack's skills.
+    externalDirs: []
+  });
+  const packSkills = [];
+  for (const metadata of discovery.skills) {
+    const content = await loadSkillContent(metadata);
+    const resources = content.resources.map((r) => ({
+      relativePath: r.relativePath,
+      type: r.type,
+      // Keep absolutePath — the resource file is on disk and will be
+      // loaded lazily when the agent calls skill_resource.
+      absolutePath: r.absolutePath
+    }));
+    packSkills.push({
+      name: metadata.name,
+      description: metadata.description,
+      body: content.body,
+      version: metadata.version,
+      tags: metadata.tags,
+      dependencies: metadata.dependencies,
+      resources: resources.length > 0 ? resources : void 0
+    });
+  }
+  return packSkills;
+}
+async function resolveLocalPlugin(packDir, pluginEntry) {
+  if (!pluginEntry) {
+    return void 0;
+  }
+  if (typeof pluginEntry !== "string" || pluginEntry.trim() === "") {
+    throw new Error(
+      `Invalid "plugin" entry in pack.json at ${packDir}. Expected a non-empty relative module path.`
+    );
+  }
+  return loadPluginModule(resolve(packDir, pluginEntry));
+}
+
+// src/sources/npm-source.ts
+async function resolveNpmPack(ref) {
+  let mod;
+  try {
+    mod = await import(ref.package);
+  } catch (err) {
+    throw new Error(
+      `Failed to import pack package "${ref.package}": ${err instanceof Error ? err.message : String(err)}. Ensure the package is installed in your workspace.`
+    );
+  }
+  const exportName = ref.export ?? "default";
+  const value = mod[exportName];
+  if (value === void 0) {
+    const available = Object.keys(mod).join(", ") || "(none)";
+    throw new Error(
+      `Package "${ref.package}" does not have a "${exportName}" export. Available exports: ${available}.`
+    );
+  }
+  const pack = value;
+  validatePackManifest(pack, `${ref.package}#${exportName}`);
+  return normalizePackManifest(pack);
+}
+
+// src/sources/url-source.ts
+var FETCH_TIMEOUT_MS = 15e3;
+async function resolveUrlPack(ref) {
+  if (!ref.url.startsWith("https://")) {
+    throw new Error(
+      `URL pack source must use HTTPS. Got: "${ref.url}". Plain HTTP is not allowed \u2014 capability packs must be served over a secure connection.`
+    );
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  let response;
+  try {
+    response = await fetch(ref.url, {
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+  } catch (err) {
+    throw new Error(
+      `Failed to fetch pack from "${ref.url}": ${err instanceof Error ? err.message : String(err)}.`
+    );
+  } finally {
+    clearTimeout(timeout);
+  }
+  if (!response.ok) {
+    throw new Error(
+      `Pack fetch from "${ref.url}" returned HTTP ${response.status} ${response.statusText}.`
+    );
+  }
+  let manifest;
+  try {
+    manifest = await response.json();
+  } catch {
+    throw new Error(`Pack from "${ref.url}" did not return valid JSON.`);
+  }
+  validatePackManifest(manifest, ref.url);
+  const pack = manifest;
+  assertNoPluginInUrlPack(pack, ref.url);
+  return normalizePackManifest(pack);
+}
+
+// src/sources/git-source.ts
+import { execFile } from "child_process";
+import { createHash } from "crypto";
+import { mkdir, rm, stat } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function gitCacheRoot() {
+  return join2(homedir(), ".cache", "cuylabs", "packs", "git");
+}
+function slugify(url, ref) {
+  const readable = url.replace(/^https?:\/\//, "").replace(/^git@/, "").replace(/[/:. ]/g, "-").replace(/-+/g, "-").replace(/\.git$/, "");
+  const hash = createHash("sha256").update(`${url}#${ref ?? ""}`).digest("hex").slice(0, 12);
+  return `${readable}--${hash}`;
+}
+async function resolveGitPack(ref) {
+  const cacheRoot = gitCacheRoot();
+  const repoDir = join2(cacheRoot, slugify(ref.url, ref.ref));
+  await ensureCloned(repoDir, ref);
+  return resolveLocalPack({ source: "local", path: repoDir });
+}
+async function ensureCloned(repoDir, ref) {
+  const alreadyCloned = await directoryExists(repoDir);
+  if (!alreadyCloned) {
+    await mkdir(gitCacheRoot(), { recursive: true });
+    await gitClone(ref.url, ref.ref, repoDir);
+  } else if (!isFixedRef(ref.ref)) {
+    await gitPull(repoDir);
+  }
+}
+function isFixedRef(ref) {
+  if (!ref) return false;
+  if (/^[0-9a-f]{40}$/i.test(ref)) return true;
+  if (/^[0-9a-f]{7,}$/i.test(ref)) return true;
+  return false;
+}
+async function gitClone(url, ref, target) {
+  const args = ["clone", "--depth=1"];
+  if (ref && !isFixedRef(ref)) args.push("--branch", ref);
+  args.push(url, target);
+  try {
+    await git(args, ".");
+    if (ref && isFixedRef(ref)) {
+      await git(["fetch", "--depth=1", "origin", ref], target);
+      await git(["checkout", "FETCH_HEAD"], target);
+    }
+  } catch (err) {
+    await rm(target, { recursive: true, force: true });
+    throw err;
+  }
+}
+async function gitPull(repoDir) {
+  await git(["pull", "--ff-only"], repoDir);
+}
+async function git(args, cwd) {
+  try {
+    await execFileAsync("git", args, { cwd });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`git ${args[0]} failed: ${msg}`);
+  }
+}
+async function directoryExists(path) {
+  try {
+    const info = await stat(path);
+    return info.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/sources/resolve.ts
+async function resolvePackRef(ref) {
+  switch (ref.source) {
+    case "inline":
+      return resolveInlinePack(ref);
+    case "local":
+      return resolveLocalPack(ref);
+    case "npm":
+      return resolveNpmPack(ref);
+    case "url":
+      return resolveUrlPack(ref);
+    case "git":
+      return resolveGitPack(ref);
+    default: {
+      const _exhaustive = ref;
+      throw new Error(
+        `Unknown pack source: "${_exhaustive.source}"`
+      );
+    }
+  }
+}
+
+export {
+  CAPABILITY_PACK_KIND,
+  CAPABILITY_PACK_SCHEMA_VERSION,
+  resolvePackRef
+};
+//# sourceMappingURL=chunk-5E66GFAI.js.map