@modootoday/pmcp 0.5.1 → 0.7.0

package/dist/chunk-NI2OLZPA.js

@@ -0,0 +1,160 @@
+import {
+  openDatabase
+} from "./chunk-ZLELYZHL.js";
+
+// src/embed.ts
+var DEFAULT_MODEL_ID = "Xenova/multilingual-e5-small";
+var PLAIN = {
+  queryPrefix: "",
+  passagePrefix: "",
+  pooling: "mean"
+};
+var E5 = {
+  queryPrefix: "query: ",
+  passagePrefix: "passage: ",
+  pooling: "mean"
+};
+var KNOWN_ENCODERS = {
+  "Xenova/multilingual-e5-small": E5,
+  "Xenova/multilingual-e5-base": E5,
+  "Xenova/multilingual-e5-large": E5,
+  "Xenova/bge-m3": { ...PLAIN, pooling: "cls" }
+};
+function encoderSpec(modelId) {
+  return KNOWN_ENCODERS[modelId] ?? PLAIN;
+}
+var ENTRY_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS entry_vector (
+    name TEXT NOT NULL,
+    model_id TEXT NOT NULL,
+    dims INTEGER NOT NULL,
+    description_hash TEXT NOT NULL,
+    vector BLOB NOT NULL,
+    PRIMARY KEY (name, model_id)
+  );
+`;
+var TRANSFORMERS = "@huggingface/transformers";
+async function loadEmbedder(modelId = DEFAULT_MODEL_ID, options = {}) {
+  let module;
+  try {
+    module = options.module ?? await import(TRANSFORMERS);
+  } catch {
+    return null;
+  }
+  const factory = module.pipeline;
+  if (typeof factory !== "function") return null;
+  if (module.env) {
+    if (options.cacheDir !== void 0)
+      module.env["cacheDir"] = options.cacheDir;
+    if (options.localOnly) module.env["allowRemoteModels"] = false;
+  }
+  const encode = await factory("feature-extraction", modelId, {
+    dtype: options.dtype ?? "q8"
+  });
+  const spec = encoderSpec(modelId);
+  let dims = 0;
+  const run = async (text) => {
+    const output = await encode(text, {
+      pooling: spec.pooling,
+      normalize: true
+    });
+    const vector = Float32Array.from(output.data);
+    dims = vector.length;
+    return vector;
+  };
+  return {
+    modelId,
+    get dims() {
+      return dims;
+    },
+    embed: (text) => run(spec.queryPrefix + text),
+    embedPassage: (text) => run(spec.passagePrefix + text)
+  };
+}
+async function encodeEntries(embedder, entries, previous = /* @__PURE__ */ new Map()) {
+  const out = /* @__PURE__ */ new Map();
+  const passage = (text) => embedder.embedPassage ? embedder.embedPassage(text) : embedder.embed(text);
+  for (const entry of entries) {
+    const hash = describeHash(entry.description);
+    const kept = previous.get(entry.name);
+    if (kept && kept.hash === hash) {
+      out.set(entry.name, kept);
+      continue;
+    }
+    out.set(entry.name, { hash, vector: await passage(entry.description) });
+  }
+  return out;
+}
+function describeHash(description) {
+  let hash = 2166136261;
+  for (let i = 0; i < description.length; i++) {
+    hash ^= description.charCodeAt(i);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+async function openEntryVectors(path) {
+  const opened = await openDatabase(path);
+  if (opened === null) return null;
+  const db = opened.db;
+  db.exec(ENTRY_SCHEMA);
+  return {
+    read(modelId) {
+      const out = /* @__PURE__ */ new Map();
+      const rows = db.prepare(
+        "SELECT name, dims, vector FROM entry_vector WHERE model_id = ?"
+      ).all(modelId);
+      for (const row of rows) {
+        const bytes = row.vector;
+        const vector = new Float32Array(
+          bytes.buffer.slice(
+            bytes.byteOffset,
+            bytes.byteOffset + bytes.byteLength
+          )
+        );
+        if (vector.length === row.dims) out.set(row.name, vector);
+      }
+      return out;
+    },
+    stale(modelId, entries) {
+      const rows = db.prepare(
+        "SELECT name, description_hash FROM entry_vector WHERE model_id = ?"
+      ).all(modelId);
+      const stored = new Map(
+        rows.map((row) => [row.name, row.description_hash])
+      );
+      const out = [];
+      for (const [name, description] of entries) {
+        if (stored.get(name) !== describeHash(description)) out.push(name);
+      }
+      return out;
+    },
+    write(modelId, name, description, vector) {
+      db.prepare(
+        `INSERT INTO entry_vector (name, model_id, dims, description_hash, vector)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(name, model_id) DO UPDATE SET
+           dims = excluded.dims,
+           description_hash = excluded.description_hash,
+           vector = excluded.vector`
+      ).run(
+        name,
+        modelId,
+        vector.length,
+        describeHash(description),
+        new Uint8Array(vector.buffer, vector.byteOffset, vector.byteLength)
+      );
+    },
+    close() {
+      db.close();
+    }
+  };
+}
+
+export {
+  DEFAULT_MODEL_ID,
+  loadEmbedder,
+  encodeEntries,
+  openEntryVectors
+};
+//# sourceMappingURL=chunk-NI2OLZPA.js.map

package/dist/{chunk-ICHBC5FM.js → chunk-POJOFL4L.js}

@@ -1,6 +1,6 @@
 import {
   createSkillServer
-} from "./chunk-76UKXVUE.js";
+} from "./chunk-QHFORYIN.js";
 
 // src/stdio.ts
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
@@ -35,4 +35,4 @@ export {
   serve,
   main
 };
-//# sourceMappingURL=chunk-ICHBC5FM.js.map
+//# sourceMappingURL=chunk-POJOFL4L.js.map

package/dist/{chunk-76UKXVUE.js → chunk-QHFORYIN.js}

@@ -1129,7 +1129,7 @@ function registerSkillTools(server, tools) {
   return server;
 }
 function createSkillServer(options) {
-  const server = new McpServer({ name: SERVER_NAME, version: "0.5.1" });
+  const server = new McpServer({ name: SERVER_NAME, version: "0.7.0" });
   const tools = createSkillTools(options);
   registerSkillsExtension(server, tools.skills);
   return registerSkillTools(server, tools);
@@ -1167,4 +1167,4 @@ export {
   registerSkillTools,
   createSkillServer
 };
-//# sourceMappingURL=chunk-76UKXVUE.js.map
+//# sourceMappingURL=chunk-QHFORYIN.js.map

package/dist/{chunk-XTLANVRL.js → chunk-ZLELYZHL.js}

@@ -1,6 +1,6 @@
 import {
   normaliseIntent
-} from "./chunk-76UKXVUE.js";
+} from "./chunk-QHFORYIN.js";
 
 // src/cache.ts
 async function openDatabase(path) {
@@ -126,68 +126,9 @@ 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,
-  CONFIG_FILE,
-  ConfigError,
-  findConfig,
-  readConfig
+  openIntentCache
 };
-//# sourceMappingURL=chunk-XTLANVRL.js.map
+//# sourceMappingURL=chunk-ZLELYZHL.js.map