@modootoday/pmcp 0.9.2 → 0.11.0

package/dist/config-CJ43_oBS.d.ts

@@ -0,0 +1,49 @@
+import { E as EncoderOptions } from './encoder-DGRy9skC.js';
+
+/**
+ * `pmcp.toml`, the project's one record of where its catalog lives.
+ *
+ * Paths in it are relative to the file, so the same file works from any
+ * directory a host starts pmcp in. Catalog and embedding settings are checked
+ * here; projector sections 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[];
+}
+interface ProjectConfig {
+    /** Absolute path of the file read. */
+    readonly path: string;
+    /** Its directory; every relative path in the file resolves against it. */
+    readonly dir: string;
+    /** `[catalog]` with paths already absolute. */
+    readonly catalog: CatalogSection;
+    readonly embedding?: EmbeddingSection;
+    /** The whole document, for sections this module does not interpret. */
+    readonly raw: Readonly<Record<string, unknown>>;
+}
+interface EmbeddingSection extends EncoderOptions {
+    readonly enabled?: boolean;
+    readonly modelId?: string;
+    readonly modelPath?: string;
+    readonly cacheDir?: 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;
+/**
+ * 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 readConfig(path: string): ProjectConfig;
+
+export { CONFIG_FILE as C, type EmbeddingSection as E, type ProjectConfig as P, type CatalogSection as a, ConfigError as b, findConfig as f, readConfig as r };

package/dist/embed-BBhv3y5x.d.ts

@@ -0,0 +1,53 @@
+import { E as Embedder } from './server-CwWcRjqz.js';
+import { E as EncoderOptions } from './encoder-DGRy9skC.js';
+
+/**
+ * The optional encoder and the store for the vectors it produces.
+ *
+ * Neither the model nor its runtime is a dependency: a caller who wants
+ * semantic ranking installs the peer and runs `pmcp index`, and everything
+ * here degrades to null rather than throwing when that has not happened.
+ */
+
+interface LoadEmbedderOptions extends EncoderOptions {
+    /** Where model files live; a host bakes them into its image here. */
+    readonly cacheDir?: string;
+    readonly modelPath?: string;
+    /** Refuse to download, so a missing model is an error rather than a fetch. */
+    readonly localOnly?: boolean;
+    /** Injected for tests. The optional peer is imported otherwise. */
+    readonly module?: unknown;
+}
+/**
+ * Loads the encoder, or returns null when the peer is not installed.
+ *
+ * Absence is not failure anywhere in this package: the caller reports it and
+ * ranking stays lexical.
+ */
+declare function loadEmbedder(modelId?: string, options?: LoadEmbedderOptions): Promise<Embedder | null>;
+/**
+ * One vector per entry, reusing those whose description has not changed.
+ * Encoded as passages, the side the intent is compared against.
+ */
+declare function encodeEntries(embedder: Embedder, entries: readonly {
+    readonly name: string;
+    readonly description: string;
+}[], previous?: ReadonlyMap<string, {
+    hash: string;
+    vector: Float32Array;
+}>): Promise<Map<string, {
+    hash: string;
+    vector: Float32Array;
+}>>;
+interface EntryVectorStore {
+    read(modelId: string): Map<string, Float32Array>;
+    /** Names whose stored hash disagrees with the description they now have. */
+    stale(modelId: string, entries: ReadonlyMap<string, string>): string[];
+    write(modelId: string, name: string, description: string, vector: Float32Array): void;
+    close(): void;
+}
+declare function openEntryVectors(path: string, options?: {
+    readOnly?: boolean;
+}): Promise<EntryVectorStore | null>;
+
+export { type EntryVectorStore as E, type LoadEmbedderOptions as L, encodeEntries as e, loadEmbedder as l, openEntryVectors as o };

package/dist/encoder-DGRy9skC.d.ts

@@ -0,0 +1,36 @@
+declare const DEFAULT_MODEL_ID = "Xenova/multilingual-e5-small";
+type EncoderDtype = "q4" | "q8" | "fp32";
+interface EncoderSpec {
+    readonly queryPrefix: string;
+    readonly passagePrefix: string;
+    readonly pooling: "mean" | "cls";
+    readonly projected?: boolean;
+}
+interface EncoderOptions {
+    readonly dtype?: EncoderDtype;
+    readonly dimensions?: number;
+    readonly revision?: string;
+    readonly encoder?: Partial<EncoderSpec>;
+}
+interface EmbeddingModel {
+    readonly name: string;
+    readonly modelId: string;
+    readonly dtype: EncoderDtype;
+    readonly dtypes: readonly EncoderDtype[];
+    readonly dimensions: readonly number[];
+    readonly revision: string;
+    readonly encoder: EncoderSpec;
+}
+declare function embeddingModels(): readonly EmbeddingModel[];
+declare function encoderSpec(modelId: string): EncoderSpec;
+interface ResolvedEncoder {
+    readonly modelId: string;
+    readonly dtype: EncoderDtype;
+    readonly dimensions?: number;
+    readonly revision: string;
+    readonly encoder: EncoderSpec;
+    readonly indexKey: string;
+}
+declare function resolveEncoder(model?: string, options?: EncoderOptions): ResolvedEncoder;
+
+export { DEFAULT_MODEL_ID as D, type EncoderOptions as E, type ResolvedEncoder as R, type EmbeddingModel as a, type EncoderDtype as b, type EncoderSpec as c, encoderSpec as d, embeddingModels as e, resolveEncoder as r };

package/dist/hook-spec-PRSnYGLV.d.ts

@@ -0,0 +1,10 @@
+declare const HOOK_TOOLS: readonly ["codex", "gemini", "antigravity"];
+type HookTool = (typeof HOOK_TOOLS)[number];
+interface ShellHookSpec {
+    readonly name: string;
+    readonly command: readonly string[];
+    readonly targets: readonly HookTool[];
+    readonly timeoutMs: number;
+}
+
+export type { HookTool as H, ShellHookSpec as S };

package/dist/http.d.ts

@@ -1,42 +1,10 @@
-import { S as SkillEntry } from './catalog-BU5VLLyd.js';
-import { E as Embedder, S as SkillServerOptions } from './server-C9eO6LMI.js';
+import { S as SkillServerOptions, E as Embedder, a as SkillEntry } from './server-CwWcRjqz.js';
+import { L as LoadEmbedderOptions } from './embed-BBhv3y5x.js';
+export { l as loadEmbedder } from './embed-BBhv3y5x.js';
+import { M as MailboxService } from './service-qpCsOXkQ.js';
+export { D as DEFAULT_MODEL_ID } from './encoder-DGRy9skC.js';
 import 'zod';
 
-/**
- * The optional encoder and the store for the vectors it produces.
- *
- * Neither the model nor its runtime is a dependency: a caller who wants
- * semantic ranking installs the peer and runs `pmcp index`, and everything
- * here degrades to null rather than throwing when that has not happened.
- */
-
-/**
- * What `pmcp index` writes and what the server reads back. Multilingual, so a
- * Korean intent finds an English description (measured 20261005: 8/8 Korean
- * and 8/8 English intents in the top three over a 99-skill catalog).
- */
-declare const DEFAULT_MODEL_ID = "Xenova/multilingual-e5-small";
-interface LoadEmbedderOptions {
-    /** Where model files live; a host bakes them into its image here. */
-    readonly cacheDir?: string;
-    /** Refuse to download, so a missing model is an error rather than a fetch. */
-    readonly localOnly?: boolean;
-    /**
-     * Weight precision. q8 is a quarter of fp32's size (118 MB against 470 MB for
-     * the default model) and ranked the same in the 20261005 measurement.
-     */
-    readonly dtype?: "q8" | "fp32";
-    /** Injected for tests. The optional peer is imported otherwise. */
-    readonly module?: unknown;
-}
-/**
- * Loads the encoder, or returns null when the peer is not installed.
- *
- * Absence is not failure anywhere in this package: the caller reports it and
- * ranking stays lexical.
- */
-declare function loadEmbedder(modelId?: string, options?: LoadEmbedderOptions): Promise<Embedder | null>;
-
 /**
  * Checks a hosted skills server makes before a request reaches MCP: which browser origins
  * and Host names may call it, how large a request may be, and how often one caller may call.
@@ -74,6 +42,7 @@ interface SkillCaller {
     readonly claims?: Readonly<Record<string, unknown>>;
 }
 interface SkillHttpOptions extends SkillServerOptions {
+    readonly mailboxFor?: (caller: SkillCaller) => MailboxService | undefined | Promise<MailboxService | undefined>;
     /** Gets the Request the host's fetch received; read headers only, the body is still unread. */
     readonly authorize: (request: Request) => SkillCaller | undefined | Promise<SkillCaller | undefined>;
     /** Tiers a caller may list and load. Package skills without a tier count as open. */
@@ -111,4 +80,4 @@ interface SkillHttpHandler {
 }
 declare function createSkillHttpHandler(options: SkillHttpOptions): SkillHttpHandler;
 
-export { DEFAULT_MAX_REQUEST_BYTES, DEFAULT_MODEL_ID, DEFAULT_TIERS, Embedder, type RateLimitOptions, type SkillCaller, type SkillHttpHandler, type SkillHttpOptions, type SkillHttpSemanticOptions, createSkillHttpHandler, loadEmbedder, visibleTo };
+export { DEFAULT_MAX_REQUEST_BYTES, DEFAULT_TIERS, Embedder, type RateLimitOptions, type SkillCaller, type SkillHttpHandler, type SkillHttpOptions, type SkillHttpSemanticOptions, createSkillHttpHandler, visibleTo };