@modootoday/pmcp 0.1.4 → 0.2.0

package/dist/chunk-N3SHKKWG.js

@@ -1,363 +0,0 @@
-// src/intent.ts
-function normaliseIntent(intent) {
-  return intent.toLowerCase().replaceAll(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/u).filter(Boolean).join(" ");
-}
-
-// src/catalog.ts
-import { existsSync, readFileSync, readdirSync } from "fs";
-import { basename, dirname, join, relative } from "path";
-var SKIPPED_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  ".cache",
-  ".turbo",
-  "coverage",
-  "__tests__",
-  "__fixtures__"
-]);
-var MAX_SKILL_DEPTH = 3;
-function readFrontmatter(source) {
-  if (!source.startsWith("---")) return {};
-  const end = source.indexOf("\n---", 3);
-  if (end === -1) return {};
-  const fields = {};
-  for (const line of source.slice(3, end).split("\n")) {
-    const match = /^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/u.exec(line);
-    if (!match) continue;
-    const value = (match[2] ?? "").trim();
-    if (value === "" || value.startsWith("#")) continue;
-    fields[match[1]] = value.replace(/^["'](.*)["']$/u, "$1");
-  }
-  return fields;
-}
-function readBody(source) {
-  if (!source.startsWith("---")) return source;
-  const end = source.indexOf("\n---", 3);
-  if (end === -1) return source;
-  return source.slice(end + 4).replace(/^(?:\r?\n)+/u, "");
-}
-function skillFiles(packageDir) {
-  const found = [];
-  const stack = [[packageDir, 0]];
-  while (stack.length > 0) {
-    const next = stack.pop();
-    if (next === void 0) break;
-    const [dir, depth] = next;
-    let entries;
-    try {
-      entries = readdirSync(dir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      if (entry.isFile()) {
-        if (entry.name === "SKILL.md") found.push(join(dir, entry.name));
-        continue;
-      }
-      if (!entry.isDirectory()) continue;
-      if (SKIPPED_DIRS.has(entry.name)) continue;
-      if (depth + 1 <= MAX_SKILL_DEPTH)
-        stack.push([join(dir, entry.name), depth + 1]);
-    }
-  }
-  return found.sort();
-}
-function packageDirs(root) {
-  if (!existsSync(root)) return [];
-  const found = [];
-  for (const entry of readdirSync(root, { withFileTypes: true })) {
-    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    if (entry.name === ".bin" || entry.name === ".cache") continue;
-    const path = join(root, entry.name);
-    if (entry.name.startsWith("@")) {
-      if (!existsSync(path)) continue;
-      for (const scoped of readdirSync(path, { withFileTypes: true })) {
-        if (scoped.isDirectory() || scoped.isSymbolicLink()) {
-          found.push(join(path, scoped.name));
-        }
-      }
-      continue;
-    }
-    found.push(path);
-  }
-  return found;
-}
-function readCatalog(options) {
-  const scopes = options.scopes ?? [];
-  const found = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const root of options.roots) {
-    for (const packageDir of packageDirs(root)) {
-      const manifestPath = join(packageDir, "package.json");
-      if (!existsSync(manifestPath)) continue;
-      let packageName;
-      try {
-        const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-        if (!manifest.name) continue;
-        packageName = manifest.name;
-      } catch {
-        continue;
-      }
-      if (scopes.length > 0 && !scopes.some((s) => packageName.startsWith(s))) {
-        continue;
-      }
-      for (const path of skillFiles(packageDir)) {
-        let source;
-        try {
-          source = readFileSync(path, "utf8");
-        } catch {
-          continue;
-        }
-        const front = readFrontmatter(source);
-        const description = front["description"] ?? "";
-        if (description === "") continue;
-        const dirName = basename(dirname(path));
-        const slug = front["name"] ?? (dirName === basename(packageDir) ? packageName : dirName);
-        const name = `${packageName}/${slug}`;
-        if (seen.has(name)) continue;
-        seen.add(name);
-        found.push({
-          name,
-          package: packageName,
-          slug,
-          description,
-          path
-        });
-      }
-    }
-  }
-  return found.sort((a, b) => a.name.localeCompare(b.name));
-}
-function withoutBody({
-  path,
-  ...rest
-}) {
-  void path;
-  return rest;
-}
-function displayPath(root, entry) {
-  return relative(root, entry.path).replaceAll("\\", "/");
-}
-
-// src/find.ts
-var DEFAULT_FIND_LIMIT = 5;
-function tokens(text) {
-  return normaliseIntent(text).split(" ").filter(Boolean);
-}
-function bigrams(text) {
-  const flat = normaliseIntent(text).replaceAll(" ", "");
-  const out = /* @__PURE__ */ new Set();
-  for (let i = 0; i + 1 < flat.length; i += 1) out.add(flat.slice(i, i + 2));
-  return out;
-}
-function lexicalScore(intent, description) {
-  const wanted = tokens(intent);
-  if (wanted.length === 0) return 0;
-  const have = new Set(tokens(description));
-  const overlap = wanted.filter((token) => have.has(token)).length / wanted.length;
-  const a = bigrams(intent);
-  const b = bigrams(description);
-  if (a.size === 0 || b.size === 0) return overlap / 2;
-  let shared = 0;
-  for (const gram of a) if (b.has(gram)) shared += 1;
-  const dice = 2 * shared / (a.size + b.size);
-  return (overlap + dice) / 2;
-}
-function cosine(a, b) {
-  if (a.length !== b.length) return 0;
-  let dot = 0;
-  let na = 0;
-  let nb = 0;
-  for (let i = 0; i < a.length; i += 1) {
-    dot += a[i] * b[i];
-    na += a[i] * a[i];
-    nb += b[i] * b[i];
-  }
-  if (na === 0 || nb === 0) return 0;
-  return dot / (Math.sqrt(na) * Math.sqrt(nb));
-}
-async function find(options) {
-  const limit = options.limit ?? DEFAULT_FIND_LIMIT;
-  const semantic = options.embedder !== void 0 && options.vectors !== void 0 && options.vectors.size > 0;
-  if (semantic) {
-    const embedder = options.embedder;
-    const vectors = options.vectors;
-    let query = options.cache?.get(options.intent) ?? null;
-    if (!query) {
-      query = await embedder.embed(options.intent);
-      options.cache?.put(options.intent, query);
-    }
-    const scored = [];
-    for (const entry of options.entries) {
-      const vector = vectors.get(entry.name);
-      if (!vector) continue;
-      scored.push({
-        name: entry.name,
-        package: entry.package,
-        description: entry.description,
-        score: cosine(query, vector)
-      });
-    }
-    if (scored.length === options.entries.length) {
-      return {
-        ranking: "semantic",
-        matches: rank(scored, limit)
-      };
-    }
-  }
-  return {
-    ranking: "lexical",
-    matches: rank(
-      options.entries.map((entry) => ({
-        name: entry.name,
-        package: entry.package,
-        description: entry.description,
-        score: lexicalScore(options.intent, entry.description)
-      })),
-      limit
-    )
-  };
-}
-function rank(matches, limit) {
-  return matches.filter((match) => match.score > 0).sort((a, b) => b.score - a.score || a.name.localeCompare(b.name)).slice(0, limit);
-}
-
-// src/server.ts
-import { readFileSync as readFileSync2 } from "fs";
-function createSkillTools(options) {
-  const load = options.loadCatalog ?? readCatalog;
-  let entries = null;
-  const catalog = () => {
-    entries ??= load({ roots: options.roots, scopes: options.scopes });
-    return entries;
-  };
-  return {
-    /** Grouped, and without bodies. The cheap overview and the search's miss path. */
-    catalog() {
-      const byPackage = /* @__PURE__ */ new Map();
-      for (const entry of catalog()) {
-        const list = byPackage.get(entry.package) ?? [];
-        list.push({ name: entry.name, description: entry.description });
-        byPackage.set(entry.package, list);
-      }
-      return {
-        count: catalog().length,
-        packages: [...byPackage.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([pkg, skills]) => ({ package: pkg, skills }))
-      };
-    },
-    /** Ranked names. Returns; never loads a body. */
-    find(intent, limit) {
-      return find({
-        entries: catalog(),
-        intent,
-        limit,
-        embedder: options.embedder,
-        cache: options.cache,
-        vectors: options.vectors
-      });
-    },
-    /** One body, at the moment it is needed. */
-    call(name) {
-      const entry = catalog().find((candidate) => candidate.name === name);
-      if (!entry) return null;
-      return {
-        name: entry.name,
-        body: readBody(readFileSync2(entry.path, "utf8"))
-      };
-    },
-    /** Drops the memoised catalog, so the next call re-reads the tree. */
-    refresh() {
-      entries = null;
-    },
-    entries: () => catalog().map(withoutBody)
-  };
-}
-
-// src/mcp.ts
-import { McpServer } from "@modelcontextprotocol/server";
-import { z } from "zod";
-var SERVER_NAME = "pmcp";
-var readOnly = {
-  readOnlyHint: true,
-  destructiveHint: false,
-  idempotentHint: true,
-  openWorldHint: false
-};
-var asText = (value) => ({
-  content: [{ type: "text", text: JSON.stringify(value, null, 2) }]
-});
-function registerSkillTools(server, tools) {
-  server.registerTool(
-    "skill_catalog",
-    {
-      title: "List installed skills without their bodies",
-      description: "Every skill the installed packages ship, grouped by package, with names and one-line descriptions and no bodies. Use it to see what exists, or when skill_find returns nothing.",
-      inputSchema: z.object({}),
-      annotations: readOnly
-    },
-    async () => asText(tools.catalog())
-  );
-  server.registerTool(
-    "skill_find",
-    {
-      title: "Find skills by describing the problem",
-      description: "Ranked skill names for an intent. Describe the problem in a full sentence in English rather than a keyword: a single word matches far worse, and the ranking is over descriptions. Returns names only -- read one with skill_call.",
-      inputSchema: z.object({
-        intent: z.string().min(1).max(256).describe("What you are trying to do, as an English sentence."),
-        limit: z.number().int().min(1).max(25).optional()
-      }),
-      annotations: readOnly
-    },
-    async ({ intent, limit }) => asText(await tools.find(intent, limit))
-  );
-  server.registerTool(
-    "skill_call",
-    {
-      title: "Read one skill",
-      description: "The body of a single skill, by the name skill_find or skill_catalog returned. This is the only call that costs a document.",
-      inputSchema: z.object({
-        name: z.string().min(1).describe("The skill name, as <package>/<slug>.")
-      }),
-      annotations: readOnly
-    },
-    async ({ name }) => {
-      const found = tools.call(name);
-      if (!found) {
-        return {
-          ...asText({
-            error: "unknown_skill",
-            name,
-            hint: "Call skill_catalog for the names that exist."
-          }),
-          isError: true
-        };
-      }
-      return { content: [{ type: "text", text: found.body }] };
-    }
-  );
-  return server;
-}
-function createSkillServer(options) {
-  const server = new McpServer({ name: SERVER_NAME, version: "0.1.4" });
-  return registerSkillTools(server, createSkillTools(options));
-}
-
-export {
-  normaliseIntent,
-  SKIPPED_DIRS,
-  MAX_SKILL_DEPTH,
-  readFrontmatter,
-  readBody,
-  readCatalog,
-  withoutBody,
-  displayPath,
-  DEFAULT_FIND_LIMIT,
-  lexicalScore,
-  cosine,
-  find,
-  createSkillTools,
-  SERVER_NAME,
-  registerSkillTools,
-  createSkillServer
-};
-//# sourceMappingURL=chunk-N3SHKKWG.js.map