@modootoday/pmcp 0.3.0 → 0.5.0

package/dist/{chunk-MBAXK4IZ.js → chunk-PUGLIJYM.js}

@@ -1,6 +1,6 @@
 import {
   normaliseIntent
-} from "./chunk-SPWHSHOC.js";
+} from "./chunk-JOQTOVTJ.js";
 
 // src/cache.ts
 async function openDatabase(path) {
@@ -126,9 +126,68 @@ async function openIntentCache(options) {
   };
 }
 
+// src/config.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { parse } from "smol-toml";
+var CONFIG_FILE = "pmcp.toml";
+var ConfigError = class extends Error {
+  constructor(path, message) {
+    super(`${path}: ${message}`);
+    this.name = "ConfigError";
+  }
+};
+var PATH_KEYS = ["roots", "workspaces", "packages", "marketplaces"];
+var CATALOG_KEYS = /* @__PURE__ */ new Set([...PATH_KEYS, "scopes"]);
+function findConfig(start) {
+  let dir = resolve(start);
+  for (; ; ) {
+    const candidate = join(dir, CONFIG_FILE);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function stringList(path, key, value) {
+  if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) {
+    throw new ConfigError(path, `[catalog] ${key} must be a list of strings`);
+  }
+  return value;
+}
+function readConfig(path) {
+  const absolute = resolve(path);
+  const dir = dirname(absolute);
+  let raw;
+  try {
+    raw = parse(readFileSync(absolute, "utf8"));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "unreadable";
+    throw new ConfigError(absolute, reason.split("\n")[0] ?? reason);
+  }
+  const section = raw["catalog"];
+  if (section === void 0) return { path: absolute, dir, catalog: {}, raw };
+  if (section === null || typeof section !== "object" || Array.isArray(section)) {
+    throw new ConfigError(absolute, "[catalog] must be a table");
+  }
+  const catalog = {};
+  for (const [key, value] of Object.entries(section)) {
+    if (!CATALOG_KEYS.has(key)) {
+      throw new ConfigError(absolute, `unknown key [catalog] ${key}`);
+    }
+    const list = stringList(absolute, key, value);
+    catalog[key] = key === "scopes" ? list : list.map((p) => resolve(dir, p));
+  }
+  return { path: absolute, dir, catalog, raw };
+}
+
 export {
   openDatabase,
   DEFAULT_INTENT_CACHE_LIMIT,
-  openIntentCache
+  openIntentCache,
+  CONFIG_FILE,
+  ConfigError,
+  findConfig,
+  readConfig
 };
-//# sourceMappingURL=chunk-MBAXK4IZ.js.map
+//# sourceMappingURL=chunk-PUGLIJYM.js.map

package/dist/{chunk-QJS3NYLT.js → chunk-X4LYYULW.js}

@@ -1,6 +1,6 @@
 import {
   createSkillServer
-} from "./chunk-SPWHSHOC.js";
+} from "./chunk-JOQTOVTJ.js";
 
 // src/stdio.ts
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
@@ -35,4 +35,4 @@ export {
   serve,
   main
 };
-//# sourceMappingURL=chunk-QJS3NYLT.js.map
+//# sourceMappingURL=chunk-X4LYYULW.js.map

package/dist/cli.js

@@ -1,13 +1,16 @@
 #!/usr/bin/env node
 import {
-  openDatabase
-} from "./chunk-MBAXK4IZ.js";
+  ConfigError,
+  findConfig,
+  openDatabase,
+  readConfig
+} from "./chunk-PUGLIJYM.js";
 import {
   serve
-} from "./chunk-QJS3NYLT.js";
+} from "./chunk-X4LYYULW.js";
 import {
   readCatalog
-} from "./chunk-SPWHSHOC.js";
+} from "./chunk-JOQTOVTJ.js";
 
 // src/cli/command.ts
 var ArgumentError = class extends Error {
@@ -320,17 +323,48 @@ var CATALOG_OPTIONS = [
     describe: "A workspace root, or a glob of them: each root and every member its workspaces globs name. Repeatable.",
     repeat: true,
     placeholder: "<dir>"
+  },
+  {
+    name: "config",
+    describe: "A pmcp.toml to read instead of the nearest one at or above the working directory.",
+    placeholder: "<file>"
+  },
+  {
+    name: "no-config",
+    describe: "Ignore pmcp.toml; only the flags given count.",
+    boolean: true
   }
 ];
+function configFrom(context) {
+  if (context.args.flags.has("no-config")) return null;
+  const named = one(context.args, "config");
+  const path = named ?? findConfig(context.cwd);
+  if (path === null) return null;
+  try {
+    return readConfig(path);
+  } catch (error) {
+    if (error instanceof ConfigError) throw new ArgumentError(error.message);
+    if (named !== void 0) throw new ArgumentError(`cannot read ${named}`);
+    throw error;
+  }
+}
 function rootsFrom(context) {
   const given = many(context.args, "root");
-  return given.length > 0 ? given : [`${context.cwd}/node_modules`];
+  if (given.length > 0) return given;
+  const config = configFrom(context);
+  if (config?.catalog.roots !== void 0) return config.catalog.roots;
+  return [`${config?.dir ?? context.cwd}/node_modules`];
 }
 function catalogOptionsFrom(context, onReject) {
-  const scopes = many(context.args, "scope");
-  const marketplaces = many(context.args, "marketplace");
-  const packages = many(context.args, "package");
-  const workspaces = many(context.args, "workspace");
+  const config = configFrom(context)?.catalog ?? {};
+  const pick = (flag, fromFile) => {
+    const given = many(context.args, flag);
+    return given.length > 0 ? given : fromFile ?? [];
+  };
+  const scopes = pick("scope", config.scopes);
+  const marketplaces = pick("marketplace", config.marketplaces);
+  const packages = pick("package", config.packages);
+  const workspaces = pick("workspace", config.workspaces);
   return {
     roots: rootsFrom(context),
     ...scopes.length > 0 ? { scopes } : {},
@@ -449,7 +483,7 @@ var indexCommand = {
 var listCommand = {
   name: "list",
   describe: "List the skills discovered in node_modules and marketplaces",
-  usage: "pmcp list [--root <dir>] [--scope <prefix>] [--marketplace <dir>] [--package <dir>] [--workspace <dir|glob>] [--json]",
+  usage: "pmcp list [--root <dir>] [--scope <prefix>] [--marketplace <dir>] [--package <dir>] [--workspace <dir|glob>] [--config <file> | --no-config] [--json]",
   options: [
     ...CATALOG_OPTIONS,
     { name: "json", describe: "Emit JSON rather than a table.", boolean: true }
@@ -474,12 +508,28 @@ var listCommand = {
       return 1;
     }
     context.ui.table(
-      entries.map((entry2) => [
-        entry2.tier === void 0 ? entry2.name : `${entry2.name} [${entry2.tier}]`,
-        entry2.description
-      ])
+      entries.map((entry2) => {
+        const tags = [entry2.kind, entry2.tier].filter(Boolean).join(", ");
+        return [
+          tags === "" ? entry2.name : `${entry2.name} [${tags}]`,
+          entry2.description
+        ];
+      })
+    );
+    const counts = /* @__PURE__ */ new Map();
+    for (const entry2 of entries) {
+      const kind = entry2.kind ?? "skill";
+      counts.set(kind, (counts.get(kind) ?? 0) + 1);
+    }
+    const plural = {
+      skill: "skills",
+      agent: "agents",
+      hook: "hooks",
+      mcp: "MCP servers"
+    };
+    context.ui.success(
+      [...counts].map(([kind, n]) => `${n} ${plural[kind] ?? kind}`).join(", ")
     );
-    context.ui.success(`${entries.length} skills`);
     return rejected.length === 0 ? 0 : 1;
   }
 };
@@ -488,7 +538,7 @@ var listCommand = {
 var serveCommand = {
   name: "serve",
   describe: "Run the MCP server on stdio (the default with no command)",
-  usage: "pmcp serve [--root <dir>] [--scope <prefix>] [--marketplace <dir>] [--package <dir>] [--workspace <dir>]",
+  usage: "pmcp serve [--root <dir>] [--scope <prefix>] [--marketplace <dir>] [--package <dir>] [--workspace <dir>] [--config <file> | --no-config]",
   options: [...CATALOG_OPTIONS],
   run(context) {
     serve(catalogOptionsFrom(context));
@@ -2085,7 +2135,7 @@ function dispatch(argv, options = {}) {
   }
   return run(command, rest, { ui, env, cwd });
 }
-var VERSION = "0.3.0";
+var VERSION = "0.5.0";
 async function run(command, argv, context) {
   try {
     return await command.run({

package/dist/http.d.ts

@@ -0,0 +1,34 @@
+import { S as SkillEntry } from './catalog-5v7jrGwP.js';
+import { S as SkillServerOptions } from './server-Dm71qZgM.js';
+
+/**
+ * The catalog over streamable HTTP, for a hosted skills server.
+ *
+ * The host owns identity: it passes authorize(), which turns a request into a
+ * caller or undefined. Anonymous requests are refused; each caller sees only the
+ * tiers tiersFor() grants. The catalog is read once and filtered per request.
+ */
+
+interface SkillCaller {
+    /** Stable id of the signed-in user, recorded by the host, never by pmcp. */
+    readonly id: string;
+    /** Whatever the host's token carried; passed to tiersFor unchanged. */
+    readonly claims?: Readonly<Record<string, unknown>>;
+}
+interface SkillHttpOptions extends SkillServerOptions {
+    readonly authorize: (request: Request) => SkillCaller | undefined | Promise<SkillCaller | undefined>;
+    /** Tiers a caller may list and load. Package skills without a tier count as open. */
+    readonly tiersFor?: (caller: SkillCaller) => readonly string[];
+    /** Sent in WWW-Authenticate on a refused request, e.g. a resource metadata URL. */
+    readonly challenge?: string;
+}
+declare const DEFAULT_TIERS: readonly string[];
+declare function visibleTo(entries: readonly SkillEntry[], tiers: readonly string[]): SkillEntry[];
+interface SkillHttpHandler {
+    fetch(request: Request): Promise<Response>;
+    /** Re-read the catalog, for a host that deploys new skill releases in place. */
+    reload(): void;
+}
+declare function createSkillHttpHandler(options: SkillHttpOptions): SkillHttpHandler;
+
+export { DEFAULT_TIERS, type SkillCaller, type SkillHttpHandler, type SkillHttpOptions, createSkillHttpHandler, visibleTo };

package/dist/http.js

@@ -0,0 +1,65 @@
+import {
+  createSkillServer,
+  readCatalog
+} from "./chunk-JOQTOVTJ.js";
+
+// src/http.ts
+import {
+  createMcpHandler
+} from "@modelcontextprotocol/server";
+var DEFAULT_TIERS = ["open", "free"];
+function visibleTo(entries, tiers) {
+  const allowed = new Set(tiers);
+  return entries.filter((entry) => allowed.has(entry.tier ?? "open"));
+}
+function createSkillHttpHandler(options) {
+  const load = options.loadCatalog ?? readCatalog;
+  let all = load(options);
+  const tiersFor = options.tiersFor ?? (() => DEFAULT_TIERS);
+  const handlers = /* @__PURE__ */ new Map();
+  const handlerFor = (tiers) => {
+    const key = [...tiers].sort().join(",");
+    const cached = handlers.get(key);
+    if (cached) return cached;
+    const handler = createMcpHandler(
+      () => createSkillServer({
+        ...options,
+        loadCatalog: () => visibleTo(all, tiers)
+      })
+    );
+    handlers.set(key, handler);
+    return handler;
+  };
+  return {
+    async fetch(request) {
+      const caller = await options.authorize(request);
+      if (!caller) {
+        return new Response(JSON.stringify({ error: "unauthorized" }), {
+          status: 401,
+          headers: {
+            "content-type": "application/json",
+            "www-authenticate": options.challenge ?? "Bearer"
+          }
+        });
+      }
+      return handlerFor(tiersFor(caller)).fetch(request, {
+        authInfo: {
+          token: "",
+          clientId: caller.id,
+          scopes: [],
+          extra: { ...caller.claims }
+        }
+      });
+    },
+    reload() {
+      all = load(options);
+      handlers.clear();
+    }
+  };
+}
+export {
+  DEFAULT_TIERS,
+  createSkillHttpHandler,
+  visibleTo
+};
+//# sourceMappingURL=http.js.map

package/dist/index.d.ts

@@ -1,36 +1,9 @@
-import { S as SkillEntry, C as CatalogOptions } from './catalog-BiPLcbLu.js';
-export { M as MAX_SKILL_DEPTH, a as SKIPPED_DIRS, d as displayPath, r as readBody, b as readCatalog, c as readFrontmatter, w as withoutBody } from './catalog-BiPLcbLu.js';
+import { I as IntentCache, S as SkillServerOptions, a as SkillTools } from './server-Dm71qZgM.js';
+export { C as CATALOG_PAGE_MAX, b as CATALOG_PAGE_SIZE, c as CallResponse, d as CatalogItem, e as CatalogResponse, D as DEFAULT_FIND_LIMIT, f as DESCRIBE_FILE_LIMIT, E as Embedder, F as FindOptions, g as FindResult, h as IntentCacheStats, K as KindFilter, M as Match, R as READ_BUDGET_BYTES, i as Ranking, j as ReadResult, k as SkillFilters, l as cosine, m as createSkillTools, n as find, o as lexicalScore, p as normaliseIntent } from './server-Dm71qZgM.js';
+import { S as SkillEntry } from './catalog-5v7jrGwP.js';
+export { a as ASSET_KINDS, A as AssetKind, C as CatalogOptions, M as MAX_SKILL_DEPTH, b as SKIPPED_DIRS, d as displayPath, k as kindOf, r as readBody, c as readCatalog, e as readFrontmatter, w as withoutBody } from './catalog-5v7jrGwP.js';
 import { McpServer } from '@modelcontextprotocol/server';
 
-/**
- * The intent key and the cache contract.
- *
- * Separate from the sqlite implementation so that ranking, which needs the key
- * and the interface, does not pull a bun-only module into a consumer running
- * under node. Only `cache.ts` requires bun.
- */
-interface IntentCacheStats {
-    readonly hits: number;
-    readonly misses: number;
-    /** Rows found for the key but written by a different model. */
-    readonly mismatched: number;
-    readonly rows: number;
-    /** Which sqlite builtin answered, or absent when there is no cache. */
-    readonly provider?: string;
-}
-interface IntentCache {
-    /** The cached vector for an intent, or null when nothing usable is stored. */
-    get(intent: string): Float32Array | null;
-    put(intent: string, vector: Float32Array): void;
-    stats(): IntentCacheStats;
-    close(): void;
-}
-/**
- * Same question, differently typed. Case, punctuation and spacing only — the
- * key has to survive a caller writing "How do I wire X?" and "how do i wire x".
- */
-declare function normaliseIntent(intent: string): string;
-
 /**
  * Query vectors, kept on disk between sessions.
  *
@@ -64,70 +37,14 @@ declare const DEFAULT_INTENT_CACHE_LIMIT = 4096;
 declare function openIntentCache(options: IntentCacheOptions): Promise<IntentCache | null>;
 
 /**
- * Ranking an intent against skill descriptions.
- *
- * Semantic when an embedder is supplied, lexical otherwise, and the answer says
- * which. A caller that cannot tell the two apart cannot tell a degraded server
- * from a working one.
- */
-
-type Ranking = "semantic" | "lexical";
-interface Match {
-    readonly name: string;
-    readonly package: string;
-    readonly description: string;
-    readonly score: number;
-}
-interface FindResult {
-    readonly ranking: Ranking;
-    readonly matches: readonly Match[];
-}
-/**
- * The encoder, supplied by the caller. There is no default and no bundled
- * model: which model runs decides what the scores mean, so it is the consuming
- * repository's declaration rather than this package's.
- */
-interface Embedder {
-    readonly modelId: string;
-    readonly dims: number;
-    embed(text: string): Promise<Float32Array>;
-}
-interface FindOptions {
-    readonly entries: readonly SkillEntry[];
-    readonly intent: string;
-    readonly limit?: number;
-    readonly embedder?: Embedder;
-    readonly cache?: IntentCache;
-    /** Precomputed description vectors, keyed by skill name. */
-    readonly vectors?: ReadonlyMap<string, Float32Array>;
-}
-declare const DEFAULT_FIND_LIMIT = 5;
-/**
- * Token overlap and bigram Dice, averaged. Deterministic and dependency-free:
- * this is the answer when there is no model, so it must never be the thing
- * that fails.
- */
-declare function lexicalScore(intent: string, description: string): number;
-/** Cosine over two equal-width vectors. Zero when either has no magnitude. */
-declare function cosine(a: Float32Array, b: Float32Array): number;
-/**
- * Ranked matches, and which ranking produced them.
- *
- * Returns rather than loads: a search verb that also acts cannot be used to
- * look, and the whole reason this server exists is that looking should be
- * cheap.
- */
-declare function find(options: FindOptions): Promise<FindResult>;
-
-/**
- * Skills laid out as an agent plugin marketplace: a directory holding
- * `.claude-plugin/marketplace.json`, whose plugins keep skills at
- * `skills/<skill>/SKILL.md`. No package.json is involved, which is why the
- * node_modules walk never saw them.
+ * Assets laid out as an agent plugin marketplace: a directory holding
+ * `.claude-plugin/marketplace.json`, whose plugins keep skills, commands,
+ * agents, hooks and MCP servers in the plugin format's own places. No
+ * package.json is involved, which is why the node_modules walk never saw them.
  */
 
 type MetadataValue = string | readonly string[];
-/** Why a skill was left out rather than served. */
+/** Why an asset was left out rather than served. */
 interface Rejection {
     readonly path: string;
     readonly reason: string;
@@ -139,117 +56,48 @@ interface Rejection {
 declare function readMetadata(source: string): Record<string, MetadataValue>;
 /** The raw frontmatter text between the fences, for skill_describe. */
 declare function readFrontmatterText(source: string): string;
-/**
- * Every skill one marketplace lists. A skill whose own tier disagrees with the
- * marketplace's is rejected: a mislabelled tier is how a private skill leaks.
- */
+/** Every asset one marketplace lists. */
 declare function readMarketplace(dir: string, onReject?: (rejection: Rejection) => void): SkillEntry[];
+/** The directory or single file an entry's describe and read may open. */
+declare const assetRoot: (entry: Pick<SkillEntry, "root" | "path">) => string;
 
 /**
- * The five tools, and nothing else.
+ * `pmcp.toml`, the project's one record of where its catalog lives.
  *
- * The point of the server is that a session's startup cost does not grow with
- * the number of skills installed: the host lists five tools whatever the
- * catalog holds, and a body is read only when one is asked for.
- */
-
-/** Largest file skill_read returns. A skill needing more should split it. */
-declare const READ_BUDGET_BYTES: number;
-/** How many files skill_describe lists before saying the rest were cut. */
-declare const DESCRIBE_FILE_LIMIT = 200;
-declare const CATALOG_PAGE_SIZE = 8;
-declare const CATALOG_PAGE_MAX = 20;
-/** Equality filters over catalog fields. Unset keys match everything. */
-interface SkillFilters {
-    readonly tier?: string;
-    readonly package?: string;
-    readonly level?: string;
-    readonly domain?: string;
-    readonly medium?: string;
+ * Paths in it are relative to the file, so the same file works from any
+ * directory a host starts pmcp in. Only `[catalog]` is read here; the other
+ * sections belong to the projector and are kept as given.
+ */
+declare const CONFIG_FILE = "pmcp.toml";
+/** What `[catalog]` may say. Each mirrors the repeatable CLI flag of the same meaning. */
+interface CatalogSection {
+    readonly roots?: readonly string[];
+    readonly scopes?: readonly string[];
+    readonly workspaces?: readonly string[];
+    readonly packages?: readonly string[];
+    readonly marketplaces?: readonly string[];
 }
-type ReadResult = {
-    readonly ok: true;
-    readonly name: string;
+interface ProjectConfig {
+    /** Absolute path of the file read. */
     readonly path: string;
-    readonly bytes: number;
-    readonly sha256: string;
-    readonly text: string;
-} | {
-    readonly ok: false;
-    readonly error: string;
-    readonly detail: string;
-};
-interface SkillServerOptions extends CatalogOptions {
-    readonly embedder?: Embedder;
-    readonly cache?: IntentCache;
-    readonly vectors?: ReadonlyMap<string, Float32Array>;
-    /** Injected for tests. Reads the catalog off disk otherwise. */
-    readonly loadCatalog?: (options: CatalogOptions) => SkillEntry[];
+    /** Its directory; every relative path in the file resolves against it. */
+    readonly dir: string;
+    /** `[catalog]` with paths already absolute. */
+    readonly catalog: CatalogSection;
+    /** The whole document, for sections this module does not interpret. */
+    readonly raw: Readonly<Record<string, unknown>>;
 }
-interface CatalogResponse {
-    readonly count: number;
-    readonly page: number;
-    readonly totalPages: number;
-    readonly hasNext: boolean;
-    readonly packages: readonly {
-        readonly package: string;
-        readonly skills: readonly {
-            readonly name: string;
-            readonly description: string;
-            readonly tier?: string;
-        }[];
-    }[];
-}
-interface CallResponse {
-    readonly name: string;
-    readonly body: string;
+declare class ConfigError extends Error {
+    constructor(path: string, message: string);
 }
+/** The nearest pmcp.toml at or above start, or null when there is none. */
+declare function findConfig(start: string): string | null;
 /**
- * The catalog, the search and the read, as plain functions.
- *
- * Separate from the MCP wiring so they can be exercised without a transport,
- * and so a consumer that wants them from a hook or a script is not made to
- * speak a protocol to get them.
+ * Reads and checks one file. An unknown key under `[catalog]` is an error
+ * rather than ignored, for the same reason an unknown flag is: a misspelt
+ * `workspace = [...]` must not look like it worked.
  */
-declare function createSkillTools(options: SkillServerOptions): {
-    /**
-     * Grouped, and without bodies. The cheap overview and the search's miss
-     * path. Paged by package so a large catalog never arrives in one answer.
-     */
-    catalog(request?: {
-        page?: number;
-        pageSize?: number;
-        tier?: string;
-    }): CatalogResponse;
-    /** Ranked names. Returns; never loads a body. */
-    find(intent: string, limit?: number, filters?: SkillFilters): Promise<FindResult>;
-    /** Every property of one skill and the files it carries, without bodies. */
-    describe(name: string): {
-        name: string;
-        package: string;
-        description: string;
-        tier: string | undefined;
-        metadata: Readonly<Record<string, string | readonly string[]>>;
-        frontmatter: string;
-        files: {
-            path: string;
-            bytes: number;
-            sha256: string;
-        }[];
-        filesTruncated: boolean;
-    } | null;
-    /**
-     * One file inside a skill's directory. Paths that leave the directory,
-     * directly or through a link, are refused; nothing is ever executed.
-     */
-    read(name: string, path?: string): ReadResult;
-    /** One body, at the moment it is needed. */
-    call(name: string): CallResponse | null;
-    /** Drops the memoised catalog, so the next call re-reads the tree. */
-    refresh(): void;
-    entries: () => Omit<SkillEntry, "path">[];
-};
-type SkillTools = ReturnType<typeof createSkillTools>;
+declare function readConfig(path: string): ProjectConfig;
 
 /**
  * The five tools, spoken over MCP.
@@ -270,11 +118,42 @@ declare const SERVER_NAME = "pmcp";
  */
 declare function registerSkillTools(server: McpServer, tools: SkillTools): McpServer;
 /**
- * A server with the five tools registered.
+ * A server with the five tools and the Skills extension registered.
  *
  * The catalog is read on first use rather than here, so a host that connects
  * and never asks pays nothing for the walk.
  */
 declare function createSkillServer(options: SkillServerOptions): McpServer;
 
-export { CATALOG_PAGE_MAX, CATALOG_PAGE_SIZE, type CallResponse, CatalogOptions, type CatalogResponse, DEFAULT_FIND_LIMIT, DEFAULT_INTENT_CACHE_LIMIT, DESCRIBE_FILE_LIMIT, type Embedder, type FindOptions, type FindResult, type IntentCache, type IntentCacheOptions, type IntentCacheStats, type Match, type MetadataValue, READ_BUDGET_BYTES, type Ranking, type ReadResult, type Rejection, SERVER_NAME, SkillEntry, type SkillFilters, type SkillServerOptions, type SkillTools, cosine, createSkillServer, createSkillTools, find, lexicalScore, normaliseIntent, openIntentCache, readFrontmatterText, readMarketplace, readMetadata, registerSkillTools };
+/**
+ * The MCP Skills extension (SEP-2640): `skills/list`, `skills/get` and the
+ * skill files as `skill://pmcp/<name>/<file>` resources, so a host that speaks
+ * the extension loads skills natively instead of through the skill_* tools.
+ */
+
+declare const SKILLS_EXTENSION = "io.modelcontextprotocol/skills";
+interface SkillResource {
+    readonly uri: string;
+    readonly digest: string;
+    readonly size: number;
+}
+interface SkillExtensionEntry {
+    readonly uri: string;
+    readonly frontmatter: Readonly<Record<string, unknown>>;
+    readonly resources: readonly SkillResource[];
+}
+declare const skillUri: (entry: Pick<SkillEntry, "name">, file?: string) => string;
+/**
+ * The extension's entry for one catalog skill, or null when the skill cannot
+ * be served under SEP-2640: not a directory with SKILL.md, a frontmatter name
+ * that is missing, invalid or unlike its path, or over the per-skill limits.
+ * Such a skill stays reachable through the skill_* tools.
+ */
+declare function extensionEntry(entry: SkillEntry): SkillExtensionEntry | null;
+/**
+ * Declares the extension and its methods on a server, over the skills the
+ * catalog function returns. Must run before the server connects.
+ */
+declare function registerSkillsExtension(server: McpServer, skills: () => readonly SkillEntry[]): void;
+
+export { CONFIG_FILE, type CatalogSection, ConfigError, DEFAULT_INTENT_CACHE_LIMIT, IntentCache, type IntentCacheOptions, type MetadataValue, type ProjectConfig, type Rejection, SERVER_NAME, SKILLS_EXTENSION, SkillEntry, type SkillExtensionEntry, type SkillResource, SkillServerOptions, SkillTools, assetRoot, createSkillServer, extensionEntry, findConfig, openIntentCache, readConfig, readFrontmatterText, readMarketplace, readMetadata, registerSkillTools, registerSkillsExtension, skillUri };