folderblog 0.0.2 → 0.0.3

package/dist/plugins/embed-cloudflare-ai.d.ts

@@ -0,0 +1,73 @@
+import { T as TextEmbeddingPlugin, P as PluginContext } from '../config-Dctsdeo6.js';
+import '../output-0P0br3Jc.js';
+
+/**
+ * Cloudflare Workers AI Text Embedding Plugin
+ *
+ * Uses Cloudflare Workers AI for text embeddings.
+ * Supports both:
+ * - Binding mode: When running inside a Cloudflare Worker (env.AI)
+ * - REST API mode: When running outside CF (uses fetch)
+ *
+ * Available models:
+ * - @cf/baai/bge-small-en-v1.5 (384 dims, fast, English)
+ * - @cf/baai/bge-base-en-v1.5 (768 dims, balanced, English)
+ * - @cf/baai/bge-large-en-v1.5 (1024 dims, best quality, English)
+ * - @cf/baai/bge-m3 (1024 dims, multilingual)
+ *
+ * @example
+ * ```ts
+ * // In a Cloudflare Worker:
+ * import { createCloudflareAIEmbedderWithBinding } from 'folderblog/plugins/embed-cloudflare-ai';
+ * const embedder = createCloudflareAIEmbedderWithBinding(env.AI);
+ *
+ * // External via REST API:
+ * import { createCloudflareAIEmbedderFromEnv } from 'folderblog/plugins/embed-cloudflare-ai';
+ * const embedder = createCloudflareAIEmbedderFromEnv();
+ * ```
+ */
+
+interface CloudflareAIBinding {
+    run<T = unknown>(model: string, input: Record<string, unknown>): Promise<T>;
+}
+type PoolingStrategy = 'mean' | 'cls';
+interface CloudflareAIEmbedderOptions {
+    /** Cloudflare Workers AI binding (env.AI). When provided, uses direct binding. */
+    readonly binding?: CloudflareAIBinding;
+    /** Cloudflare Account ID (required for REST API mode) */
+    readonly accountId?: string;
+    /** Cloudflare API Token with Workers AI permissions (required for REST API mode) */
+    readonly apiToken?: string;
+    /** Model ID (default: '@cf/baai/bge-small-en-v1.5') */
+    readonly modelId?: string;
+    /** Pooling strategy (default: 'cls' for better accuracy) */
+    readonly pooling?: PoolingStrategy;
+    /** Batch size for concurrent requests (default: 100) */
+    readonly batchSize?: number;
+    /** Request timeout in ms (default: 30000) */
+    readonly timeout?: number;
+}
+declare const DEFAULT_MODEL = "@cf/baai/bge-small-en-v1.5";
+declare const MODEL_DIMENSIONS: Record<string, number>;
+declare class CloudflareAITextEmbedder implements TextEmbeddingPlugin {
+    readonly name: "textEmbedder";
+    readonly model: string;
+    readonly dimensions: number;
+    private ready;
+    private context;
+    private options;
+    constructor(options?: CloudflareAIEmbedderOptions);
+    initialize(context: PluginContext): Promise<void>;
+    isReady(): boolean;
+    dispose(): Promise<void>;
+    embed(text: string): Promise<readonly number[]>;
+    batchEmbed(texts: readonly string[]): Promise<readonly (readonly number[])[]>;
+    private embedBatch;
+    private embedWithBinding;
+    private embedWithRestApi;
+}
+declare const createCloudflareAIEmbedderWithBinding: (binding: CloudflareAIBinding, options?: Omit<CloudflareAIEmbedderOptions, "binding" | "accountId" | "apiToken">) => TextEmbeddingPlugin;
+declare const createCloudflareAIEmbedderWithRestApi: (accountId: string, apiToken: string, options?: Omit<CloudflareAIEmbedderOptions, "binding" | "accountId" | "apiToken">) => TextEmbeddingPlugin;
+declare const createCloudflareAIEmbedderFromEnv: (options?: Omit<CloudflareAIEmbedderOptions, "binding" | "accountId" | "apiToken">) => TextEmbeddingPlugin;
+
+export { DEFAULT_MODEL as CLOUDFLARE_DEFAULT_MODEL, MODEL_DIMENSIONS as CLOUDFLARE_MODEL_DIMENSIONS, type CloudflareAIBinding, type CloudflareAIEmbedderOptions, CloudflareAITextEmbedder, type PoolingStrategy, createCloudflareAIEmbedderFromEnv, createCloudflareAIEmbedderWithBinding, createCloudflareAIEmbedderWithRestApi, CloudflareAITextEmbedder as default };

package/dist/plugins/embed-cloudflare-ai.js

@@ -0,0 +1,156 @@
+import '../chunk-3RG5ZIWI.js';
+
+// src/plugins/embed-cloudflare-ai.ts
+var DEFAULT_MODEL = "@cf/baai/bge-small-en-v1.5";
+var MODEL_DIMENSIONS = {
+  "@cf/baai/bge-small-en-v1.5": 384,
+  "@cf/baai/bge-base-en-v1.5": 768,
+  "@cf/baai/bge-large-en-v1.5": 1024,
+  "@cf/baai/bge-m3": 1024
+};
+var CloudflareAITextEmbedder = class {
+  name = "textEmbedder";
+  model;
+  dimensions;
+  ready = false;
+  context = null;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      binding: options.binding,
+      accountId: options.accountId,
+      apiToken: options.apiToken,
+      modelId: options.modelId ?? DEFAULT_MODEL,
+      pooling: options.pooling ?? "cls",
+      batchSize: options.batchSize ?? 100,
+      timeout: options.timeout ?? 3e4
+    };
+    this.model = this.options.modelId;
+    this.dimensions = MODEL_DIMENSIONS[this.model] ?? 384;
+  }
+  async initialize(context) {
+    this.context = context;
+    const mode = this.options.binding ? "binding" : "REST API";
+    context.log(
+      `Initializing CloudflareAITextEmbedder (${mode} mode, model: ${this.model}, pooling: ${this.options.pooling})`,
+      "info"
+    );
+    if (!this.options.binding && (!this.options.accountId || !this.options.apiToken)) {
+      throw new Error(
+        "CloudflareAITextEmbedder requires either a binding (env.AI) or accountId + apiToken for REST API mode"
+      );
+    }
+    try {
+      await this.embed("test");
+      context.log(
+        `CloudflareAITextEmbedder initialized (${this.dimensions} dimensions)`,
+        "info"
+      );
+      this.ready = true;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      context.log(`Failed to initialize Cloudflare AI embedder: ${msg}`, "error");
+      throw error;
+    }
+  }
+  isReady() {
+    return this.ready;
+  }
+  async dispose() {
+    this.ready = false;
+  }
+  async embed(text) {
+    const results = await this.batchEmbed([text]);
+    const result = results[0];
+    if (!result) {
+      throw new Error("Failed to generate embedding");
+    }
+    return result;
+  }
+  async batchEmbed(texts) {
+    if (texts.length === 0) {
+      return [];
+    }
+    const results = [];
+    const batchSize = this.options.batchSize;
+    for (let i = 0; i < texts.length; i += batchSize) {
+      const batch = texts.slice(i, i + batchSize);
+      const batchResults = await this.embedBatch(batch);
+      results.push(...batchResults);
+      if (texts.length > 50 && this.context) {
+        this.context.log(
+          `Embedding progress: ${Math.min(i + batchSize, texts.length)}/${texts.length}`,
+          "debug"
+        );
+      }
+    }
+    return results;
+  }
+  async embedBatch(texts) {
+    if (this.options.binding) {
+      return this.embedWithBinding(texts);
+    }
+    return this.embedWithRestApi(texts);
+  }
+  async embedWithBinding(texts) {
+    const binding = this.options.binding;
+    const response = await binding.run(this.model, {
+      text: texts,
+      pooling: this.options.pooling
+    });
+    if (!response?.data) {
+      throw new Error("Invalid response from Cloudflare AI binding");
+    }
+    return response.data;
+  }
+  async embedWithRestApi(texts) {
+    const url = `https://api.cloudflare.com/client/v4/accounts/${this.options.accountId}/ai/run/${this.model}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.options.apiToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          text: texts,
+          pooling: this.options.pooling
+        }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Cloudflare AI API error (${response.status}): ${errorText}`);
+      }
+      const data = await response.json();
+      if (!data.success || !data.result?.data) {
+        const errorMsg = data.errors?.[0]?.message ?? "Unknown error";
+        throw new Error(`Cloudflare AI API error: ${errorMsg}`);
+      }
+      return data.result.data;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+var createCloudflareAIEmbedderWithBinding = (binding, options) => {
+  return new CloudflareAITextEmbedder({ ...options, binding });
+};
+var createCloudflareAIEmbedderWithRestApi = (accountId, apiToken, options) => {
+  return new CloudflareAITextEmbedder({ ...options, accountId, apiToken });
+};
+var createCloudflareAIEmbedderFromEnv = (options) => {
+  const accountId = process.env["CLOUDFLARE_ACCOUNT_ID"];
+  const apiToken = process.env["CLOUDFLARE_API_TOKEN"];
+  if (!accountId || !apiToken) {
+    throw new Error(
+      "CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN environment variables are required"
+    );
+  }
+  return new CloudflareAITextEmbedder({ ...options, accountId, apiToken });
+};
+var embed_cloudflare_ai_default = CloudflareAITextEmbedder;
+
+export { DEFAULT_MODEL as CLOUDFLARE_DEFAULT_MODEL, MODEL_DIMENSIONS as CLOUDFLARE_MODEL_DIMENSIONS, CloudflareAITextEmbedder, createCloudflareAIEmbedderFromEnv, createCloudflareAIEmbedderWithBinding, createCloudflareAIEmbedderWithRestApi, embed_cloudflare_ai_default as default };

package/dist/plugins/embed-transformers.cjs

@@ -0,0 +1,121 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../chunk-OBGZSXTJ.cjs');
+
+// src/plugins/embed-transformers.ts
+var DEFAULT_MODEL = "Xenova/all-MiniLM-L6-v2";
+var MODEL_DIMENSIONS = {
+  "Xenova/all-MiniLM-L6-v2": 384,
+  "Xenova/all-mpnet-base-v2": 768,
+  "Xenova/paraphrase-MiniLM-L6-v2": 384,
+  "Xenova/bge-small-en-v1.5": 384,
+  "Xenova/bge-base-en-v1.5": 768
+};
+var TransformersTextEmbedder = class {
+  name = "textEmbedder";
+  model;
+  dimensions;
+  ready = false;
+  context = null;
+  pipeline = null;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      modelId: options.modelId ?? DEFAULT_MODEL,
+      pooling: options.pooling ?? "mean",
+      normalize: options.normalize ?? true,
+      maxLength: options.maxLength ?? 512
+    };
+    this.model = this.options.modelId;
+    this.dimensions = MODEL_DIMENSIONS[this.model] ?? 384;
+  }
+  async initialize(context) {
+    this.context = context;
+    context.log(`Initializing TransformersTextEmbedder with ${this.model}...`, "info");
+    try {
+      const { pipeline } = await import('@huggingface/transformers');
+      this.pipeline = await pipeline("feature-extraction", this.model);
+      context.log(
+        `TransformersTextEmbedder initialized (${this.dimensions} dimensions)`,
+        "info"
+      );
+      this.ready = true;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      context.log(`Failed to initialize embedding model: ${msg}`, "error");
+      throw error;
+    }
+  }
+  isReady() {
+    return this.ready;
+  }
+  async dispose() {
+    this.pipeline = null;
+    this.ready = false;
+  }
+  async embed(text) {
+    if (!this.pipeline) {
+      throw new Error("TransformersTextEmbedder not initialized");
+    }
+    const result = await this.pipeline(text, {
+      pooling: this.options.pooling,
+      normalize: this.options.normalize
+    });
+    return this.extractEmbedding(result);
+  }
+  async batchEmbed(texts) {
+    if (!this.pipeline) {
+      throw new Error("TransformersTextEmbedder not initialized");
+    }
+    const batchSize = 16;
+    const results = [];
+    for (let i = 0; i < texts.length; i += batchSize) {
+      const batch = texts.slice(i, i + batchSize);
+      for (const text of batch) {
+        const result = await this.pipeline(text, {
+          pooling: this.options.pooling,
+          normalize: this.options.normalize
+        });
+        results.push(this.extractEmbedding(result));
+      }
+      if (texts.length > 50 && this.context) {
+        this.context.log(
+          `Embedding progress: ${Math.min(i + batchSize, texts.length)}/${texts.length}`,
+          "debug"
+        );
+      }
+    }
+    return results;
+  }
+  extractEmbedding(result) {
+    if (result && typeof result.tolist === "function") {
+      const list = result.tolist();
+      if (Array.isArray(list) && list.length === 1) {
+        return list[0];
+      }
+      return list;
+    }
+    if (result && result.data) {
+      return Array.from(result.data);
+    }
+    if (Array.isArray(result)) {
+      if (Array.isArray(result[0])) {
+        return result[0];
+      }
+      return result;
+    }
+    return new Array(this.dimensions).fill(0);
+  }
+};
+var createTransformersEmbedder = (options) => {
+  return new TransformersTextEmbedder(options);
+};
+var embed_transformers_default = TransformersTextEmbedder;
+
+exports.DEFAULT_MODEL = DEFAULT_MODEL;
+exports.MODEL_DIMENSIONS = MODEL_DIMENSIONS;
+exports.TransformersTextEmbedder = TransformersTextEmbedder;
+exports.createTransformersEmbedder = createTransformersEmbedder;
+exports.default = embed_transformers_default;

package/dist/plugins/embed-transformers.d.cts

@@ -0,0 +1,55 @@
+import { T as TextEmbeddingPlugin, P as PluginContext } from '../config-ADPY6IQS.cjs';
+import '../output-0P0br3Jc.cjs';
+
+/**
+ * Transformers.js Text Embedding Plugin
+ *
+ * Uses HuggingFace Transformers.js for local text embeddings.
+ * Supports various sentence transformer models.
+ *
+ * Requires: `@huggingface/transformers` (optional peer dependency)
+ *
+ * @example
+ * ```ts
+ * import { createTransformersEmbedder } from 'folderblog/plugins/embed-transformers';
+ *
+ * const embedder = createTransformersEmbedder({
+ *   modelId: 'Xenova/all-MiniLM-L6-v2',
+ * });
+ * ```
+ */
+
+interface TransformersEmbedderOptions {
+    /** Model ID from HuggingFace (default: 'Xenova/all-MiniLM-L6-v2') */
+    readonly modelId?: string;
+    /** Pooling strategy (default: 'mean') */
+    readonly pooling?: 'mean' | 'cls' | 'none';
+    /** Normalize embeddings (default: true) */
+    readonly normalize?: boolean;
+    /** Maximum sequence length (default: 512) */
+    readonly maxLength?: number;
+}
+declare const DEFAULT_MODEL = "Xenova/all-MiniLM-L6-v2";
+declare const MODEL_DIMENSIONS: Record<string, number>;
+declare class TransformersTextEmbedder implements TextEmbeddingPlugin {
+    readonly name: "textEmbedder";
+    readonly model: string;
+    readonly dimensions: number;
+    private ready;
+    private context;
+    private pipeline;
+    private options;
+    constructor(options?: TransformersEmbedderOptions);
+    initialize(context: PluginContext): Promise<void>;
+    isReady(): boolean;
+    dispose(): Promise<void>;
+    embed(text: string): Promise<readonly number[]>;
+    batchEmbed(texts: readonly string[]): Promise<readonly (readonly number[])[]>;
+    private extractEmbedding;
+}
+/**
+ * Create a Transformers.js text embedder plugin
+ */
+declare const createTransformersEmbedder: (options?: TransformersEmbedderOptions) => TextEmbeddingPlugin;
+
+export { DEFAULT_MODEL, MODEL_DIMENSIONS, type TransformersEmbedderOptions, TransformersTextEmbedder, createTransformersEmbedder, TransformersTextEmbedder as default };

package/dist/plugins/embed-transformers.d.ts

@@ -0,0 +1,55 @@
+import { T as TextEmbeddingPlugin, P as PluginContext } from '../config-Dctsdeo6.js';
+import '../output-0P0br3Jc.js';
+
+/**
+ * Transformers.js Text Embedding Plugin
+ *
+ * Uses HuggingFace Transformers.js for local text embeddings.
+ * Supports various sentence transformer models.
+ *
+ * Requires: `@huggingface/transformers` (optional peer dependency)
+ *
+ * @example
+ * ```ts
+ * import { createTransformersEmbedder } from 'folderblog/plugins/embed-transformers';
+ *
+ * const embedder = createTransformersEmbedder({
+ *   modelId: 'Xenova/all-MiniLM-L6-v2',
+ * });
+ * ```
+ */
+
+interface TransformersEmbedderOptions {
+    /** Model ID from HuggingFace (default: 'Xenova/all-MiniLM-L6-v2') */
+    readonly modelId?: string;
+    /** Pooling strategy (default: 'mean') */
+    readonly pooling?: 'mean' | 'cls' | 'none';
+    /** Normalize embeddings (default: true) */
+    readonly normalize?: boolean;
+    /** Maximum sequence length (default: 512) */
+    readonly maxLength?: number;
+}
+declare const DEFAULT_MODEL = "Xenova/all-MiniLM-L6-v2";
+declare const MODEL_DIMENSIONS: Record<string, number>;
+declare class TransformersTextEmbedder implements TextEmbeddingPlugin {
+    readonly name: "textEmbedder";
+    readonly model: string;
+    readonly dimensions: number;
+    private ready;
+    private context;
+    private pipeline;
+    private options;
+    constructor(options?: TransformersEmbedderOptions);
+    initialize(context: PluginContext): Promise<void>;
+    isReady(): boolean;
+    dispose(): Promise<void>;
+    embed(text: string): Promise<readonly number[]>;
+    batchEmbed(texts: readonly string[]): Promise<readonly (readonly number[])[]>;
+    private extractEmbedding;
+}
+/**
+ * Create a Transformers.js text embedder plugin
+ */
+declare const createTransformersEmbedder: (options?: TransformersEmbedderOptions) => TextEmbeddingPlugin;
+
+export { DEFAULT_MODEL, MODEL_DIMENSIONS, type TransformersEmbedderOptions, TransformersTextEmbedder, createTransformersEmbedder, TransformersTextEmbedder as default };

package/dist/plugins/embed-transformers.js

@@ -0,0 +1,113 @@
+import '../chunk-3RG5ZIWI.js';
+
+// src/plugins/embed-transformers.ts
+var DEFAULT_MODEL = "Xenova/all-MiniLM-L6-v2";
+var MODEL_DIMENSIONS = {
+  "Xenova/all-MiniLM-L6-v2": 384,
+  "Xenova/all-mpnet-base-v2": 768,
+  "Xenova/paraphrase-MiniLM-L6-v2": 384,
+  "Xenova/bge-small-en-v1.5": 384,
+  "Xenova/bge-base-en-v1.5": 768
+};
+var TransformersTextEmbedder = class {
+  name = "textEmbedder";
+  model;
+  dimensions;
+  ready = false;
+  context = null;
+  pipeline = null;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      modelId: options.modelId ?? DEFAULT_MODEL,
+      pooling: options.pooling ?? "mean",
+      normalize: options.normalize ?? true,
+      maxLength: options.maxLength ?? 512
+    };
+    this.model = this.options.modelId;
+    this.dimensions = MODEL_DIMENSIONS[this.model] ?? 384;
+  }
+  async initialize(context) {
+    this.context = context;
+    context.log(`Initializing TransformersTextEmbedder with ${this.model}...`, "info");
+    try {
+      const { pipeline } = await import('@huggingface/transformers');
+      this.pipeline = await pipeline("feature-extraction", this.model);
+      context.log(
+        `TransformersTextEmbedder initialized (${this.dimensions} dimensions)`,
+        "info"
+      );
+      this.ready = true;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      context.log(`Failed to initialize embedding model: ${msg}`, "error");
+      throw error;
+    }
+  }
+  isReady() {
+    return this.ready;
+  }
+  async dispose() {
+    this.pipeline = null;
+    this.ready = false;
+  }
+  async embed(text) {
+    if (!this.pipeline) {
+      throw new Error("TransformersTextEmbedder not initialized");
+    }
+    const result = await this.pipeline(text, {
+      pooling: this.options.pooling,
+      normalize: this.options.normalize
+    });
+    return this.extractEmbedding(result);
+  }
+  async batchEmbed(texts) {
+    if (!this.pipeline) {
+      throw new Error("TransformersTextEmbedder not initialized");
+    }
+    const batchSize = 16;
+    const results = [];
+    for (let i = 0; i < texts.length; i += batchSize) {
+      const batch = texts.slice(i, i + batchSize);
+      for (const text of batch) {
+        const result = await this.pipeline(text, {
+          pooling: this.options.pooling,
+          normalize: this.options.normalize
+        });
+        results.push(this.extractEmbedding(result));
+      }
+      if (texts.length > 50 && this.context) {
+        this.context.log(
+          `Embedding progress: ${Math.min(i + batchSize, texts.length)}/${texts.length}`,
+          "debug"
+        );
+      }
+    }
+    return results;
+  }
+  extractEmbedding(result) {
+    if (result && typeof result.tolist === "function") {
+      const list = result.tolist();
+      if (Array.isArray(list) && list.length === 1) {
+        return list[0];
+      }
+      return list;
+    }
+    if (result && result.data) {
+      return Array.from(result.data);
+    }
+    if (Array.isArray(result)) {
+      if (Array.isArray(result[0])) {
+        return result[0];
+      }
+      return result;
+    }
+    return new Array(this.dimensions).fill(0);
+  }
+};
+var createTransformersEmbedder = (options) => {
+  return new TransformersTextEmbedder(options);
+};
+var embed_transformers_default = TransformersTextEmbedder;
+
+export { DEFAULT_MODEL, MODEL_DIMENSIONS, TransformersTextEmbedder, createTransformersEmbedder, embed_transformers_default as default };

package/dist/plugins/similarity.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var chunk6TFXNIO6_cjs = require('../chunk-6TFXNIO6.cjs');
+require('../chunk-OBGZSXTJ.cjs');
+
+
+
+Object.defineProperty(exports, "CosineSimilarityPlugin", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.CosineSimilarityPlugin; }
+});
+Object.defineProperty(exports, "cosineSimilarity", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.cosineSimilarity; }
+});
+Object.defineProperty(exports, "createSimilarityPlugin", {
+  enumerable: true,
+  get: function () { return chunk6TFXNIO6_cjs.createSimilarityPlugin; }
+});

package/dist/plugins/similarity.d.cts

@@ -0,0 +1,41 @@
+import { y as SimilarityPlugin, P as PluginContext, z as SimilarityResult } from '../config-ADPY6IQS.cjs';
+import { d as ProcessedPost } from '../output-0P0br3Jc.cjs';
+
+/**
+ * Cosine Similarity Plugin
+ *
+ * Computes post similarity from text embedding vectors.
+ * Pure math — no external dependencies.
+ */
+
+interface SimilarityPluginOptions {
+    /** Number of similar posts to return per post (default: 5) */
+    readonly topN?: number;
+    /** Minimum similarity score threshold (default: 0) */
+    readonly threshold?: number;
+}
+declare class CosineSimilarityPlugin implements SimilarityPlugin {
+    readonly name: "similarity";
+    readonly requires: readonly ["textEmbedder"];
+    private ready;
+    private context;
+    private readonly topN;
+    private readonly threshold;
+    constructor(options?: SimilarityPluginOptions);
+    initialize(context: PluginContext): Promise<void>;
+    isReady(): boolean;
+    dispose(): Promise<void>;
+    computeSimilarity(a: readonly number[], b: readonly number[]): number;
+    generateSimilarityMap(posts: readonly ProcessedPost[]): Promise<SimilarityResult>;
+}
+/**
+ * Compute cosine similarity between two vectors.
+ * Returns 0 if either vector has zero magnitude.
+ */
+declare function cosineSimilarity(a: readonly number[], b: readonly number[]): number;
+/**
+ * Create a cosine similarity plugin
+ */
+declare const createSimilarityPlugin: (options?: SimilarityPluginOptions) => SimilarityPlugin;
+
+export { CosineSimilarityPlugin, type SimilarityPluginOptions, cosineSimilarity, createSimilarityPlugin };

package/dist/plugins/similarity.d.ts

@@ -0,0 +1,41 @@
+import { y as SimilarityPlugin, P as PluginContext, z as SimilarityResult } from '../config-Dctsdeo6.js';
+import { d as ProcessedPost } from '../output-0P0br3Jc.js';
+
+/**
+ * Cosine Similarity Plugin
+ *
+ * Computes post similarity from text embedding vectors.
+ * Pure math — no external dependencies.
+ */
+
+interface SimilarityPluginOptions {
+    /** Number of similar posts to return per post (default: 5) */
+    readonly topN?: number;
+    /** Minimum similarity score threshold (default: 0) */
+    readonly threshold?: number;
+}
+declare class CosineSimilarityPlugin implements SimilarityPlugin {
+    readonly name: "similarity";
+    readonly requires: readonly ["textEmbedder"];
+    private ready;
+    private context;
+    private readonly topN;
+    private readonly threshold;
+    constructor(options?: SimilarityPluginOptions);
+    initialize(context: PluginContext): Promise<void>;
+    isReady(): boolean;
+    dispose(): Promise<void>;
+    computeSimilarity(a: readonly number[], b: readonly number[]): number;
+    generateSimilarityMap(posts: readonly ProcessedPost[]): Promise<SimilarityResult>;
+}
+/**
+ * Compute cosine similarity between two vectors.
+ * Returns 0 if either vector has zero magnitude.
+ */
+declare function cosineSimilarity(a: readonly number[], b: readonly number[]): number;
+/**
+ * Create a cosine similarity plugin
+ */
+declare const createSimilarityPlugin: (options?: SimilarityPluginOptions) => SimilarityPlugin;
+
+export { CosineSimilarityPlugin, type SimilarityPluginOptions, cosineSimilarity, createSimilarityPlugin };

package/dist/plugins/similarity.js

@@ -0,0 +1,2 @@
+export { CosineSimilarityPlugin, cosineSimilarity, createSimilarityPlugin } from '../chunk-B43UAOPC.js';
+import '../chunk-3RG5ZIWI.js';