@rcrsr/rill-ext-pinecone 0.8.3 → 0.8.5

package/dist/index.js

@@ -1,9 +1,633 @@
-// ============================================================
-// VERSION
-// ============================================================
-export const VERSION = '0.0.1';
-// ============================================================
-// FACTORY
-// ============================================================
-export { createPineconeExtension } from './factory.js';
-//# sourceMappingURL=index.js.map
+// src/factory.ts
+import { Pinecone } from "@pinecone-database/pinecone";
+import {
+  RuntimeError as RuntimeError4,
+  emitExtensionEvent as emitExtensionEvent3,
+  createVector
+} from "@rcrsr/rill";
+
+// ../../shared/ext-vector/dist/errors.js
+import { RuntimeError } from "@rcrsr/rill";
+function mapVectorError(provider, error) {
+  if (!(error instanceof Error)) {
+    return new RuntimeError("RILL-R004", `${provider}: unknown error`);
+  }
+  const message = error.message;
+  if (message.includes("401") || message.toLowerCase().includes("unauthorized")) {
+    return new RuntimeError("RILL-R004", `${provider}: authentication failed (401)`);
+  }
+  if (message.toLowerCase().includes("collection") && message.toLowerCase().includes("not found")) {
+    return new RuntimeError("RILL-R004", `${provider}: collection not found`);
+  }
+  if (message.includes("429") || message.toLowerCase().includes("rate limit")) {
+    return new RuntimeError("RILL-R004", `${provider}: rate limit exceeded`);
+  }
+  if (error.name === "AbortError" || message.toLowerCase().includes("timeout")) {
+    return new RuntimeError("RILL-R004", `${provider}: request timeout`);
+  }
+  if (message.toLowerCase().includes("dimension")) {
+    const match = message.match(/expected (\d+).*got (\d+)|(\d+).*?expected.*?(\d+)/i);
+    if (match) {
+      const expected = match[1] || match[4];
+      const actual = match[2] || match[3];
+      return new RuntimeError("RILL-R004", `${provider}: dimension mismatch (expected ${expected}, got ${actual})`);
+    }
+    return new RuntimeError("RILL-R004", `${provider}: dimension mismatch`);
+  }
+  if (message.toLowerCase().includes("already exists")) {
+    return new RuntimeError("RILL-R004", `${provider}: collection already exists`);
+  }
+  return new RuntimeError("RILL-R004", `${provider}: ${message}`);
+}
+
+// ../../shared/ext-vector/dist/events.js
+import { emitExtensionEvent } from "@rcrsr/rill";
+async function withEventEmission(ctx, provider, operation, metadata, fn) {
+  const startTime = Date.now();
+  try {
+    const result = await fn();
+    const duration = Date.now() - startTime;
+    emitExtensionEvent(ctx, {
+      event: `${provider}:${operation}`,
+      subsystem: `extension:${provider}`,
+      duration,
+      ...metadata
+    });
+    return result;
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    const rillError = mapVectorError(provider, error);
+    emitExtensionEvent(ctx, {
+      event: `${provider}:error`,
+      subsystem: `extension:${provider}`,
+      error: rillError.message,
+      duration
+    });
+    throw rillError;
+  }
+}
+
+// ../../shared/ext-vector/dist/batch.js
+import { RuntimeError as RuntimeError2 } from "@rcrsr/rill";
+
+// ../../shared/ext-vector/dist/disposal.js
+import { RuntimeError as RuntimeError3 } from "@rcrsr/rill";
+function createDisposalState(_provider) {
+  return { isDisposed: false };
+}
+function checkDisposed(state, provider) {
+  if (state.isDisposed) {
+    throw new RuntimeError3("RILL-R004", `${provider}: operation cancelled`);
+  }
+}
+async function dispose(state, cleanup) {
+  if (state.isDisposed) {
+    return;
+  }
+  if (cleanup) {
+    try {
+      await cleanup();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.warn(`Cleanup failed: ${message}`);
+    }
+  }
+  state.isDisposed = true;
+}
+
+// ../../shared/ext-vector/dist/validation.js
+function assertRequired(value, fieldName) {
+  if (value === void 0) {
+    throw new Error(`${fieldName} is required`);
+  }
+  if (value === null) {
+    throw new Error(`${fieldName} is required`);
+  }
+  if (value === "") {
+    throw new Error(`${fieldName} is required`);
+  }
+}
+
+// ../../shared/ext-vector/dist/wrapper.js
+import { emitExtensionEvent as emitExtensionEvent2 } from "@rcrsr/rill";
+
+// src/factory.ts
+function mapPineconeError(error) {
+  if (error instanceof Error) {
+    const message = error.message;
+    if (message.toLowerCase().includes("authentication")) {
+      return new RuntimeError4(
+        "RILL-R004",
+        "pinecone: authentication failed (401)"
+      );
+    }
+    if (message.toLowerCase().includes("index") && message.toLowerCase().includes("not found")) {
+      return new RuntimeError4("RILL-R004", "pinecone: collection not found");
+    }
+  }
+  return mapVectorError("pinecone", error);
+}
+function createPineconeExtension(config) {
+  assertRequired(config.apiKey, "apiKey");
+  assertRequired(config.index, "index");
+  const client = new Pinecone({
+    apiKey: config.apiKey
+  });
+  const factoryIndex = config.index;
+  const factoryNamespace = config.namespace ?? "";
+  const disposalState = createDisposalState("pinecone");
+  const dispose2 = async () => {
+    await dispose(disposalState);
+  };
+  const checkDisposed2 = () => {
+    checkDisposed(disposalState, "pinecone");
+  };
+  const convertMetadata = (input) => {
+    const result2 = {};
+    for (const [key, value] of Object.entries(input)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        result2[key] = value;
+      } else {
+        result2[key] = String(value);
+      }
+    }
+    return result2;
+  };
+  const result = {
+    // IR-1: pinecone::upsert
+    upsert: {
+      params: [
+        { name: "id", type: "string" },
+        { name: "vector", type: "vector" },
+        { name: "metadata", type: "dict", defaultValue: {} }
+      ],
+      fn: async (args, ctx) => {
+        checkDisposed2();
+        const id = args[0];
+        const vector = args[1];
+        const metadataArg = args[2] ?? {};
+        const metadata = convertMetadata(metadataArg);
+        return withEventEmission(
+          ctx,
+          "pinecone",
+          "upsert",
+          { id },
+          async () => {
+            const index = client.Index(factoryIndex);
+            await index.namespace(factoryNamespace).upsert([
+              {
+                id,
+                values: Array.from(vector.data),
+                metadata
+              }
+            ]);
+            return {
+              id,
+              success: true
+            };
+          }
+        );
+      },
+      description: "Insert or update single vector with metadata",
+      returnType: "dict"
+    },
+    // IR-2: pinecone::upsert_batch
+    upsert_batch: {
+      params: [{ name: "items", type: "list" }],
+      fn: async (args, ctx) => {
+        const startTime = Date.now();
+        try {
+          checkDisposed2();
+          const items = args[0];
+          let succeeded = 0;
+          const index = client.Index(factoryIndex);
+          for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            if (!item || typeof item !== "object") {
+              const result2 = {
+                succeeded,
+                failed: `index ${i}`,
+                error: "invalid item structure"
+              };
+              const duration2 = Date.now() - startTime;
+              emitExtensionEvent3(ctx, {
+                event: "pinecone:upsert_batch",
+                subsystem: "extension:pinecone",
+                duration: duration2,
+                count: items.length,
+                succeeded
+              });
+              return result2;
+            }
+            const id = item["id"];
+            const vector = item["vector"];
+            const metadataArg = item["metadata"] ?? {};
+            const metadata = convertMetadata(metadataArg);
+            try {
+              await index.namespace(factoryNamespace).upsert([
+                {
+                  id,
+                  values: Array.from(vector.data),
+                  metadata
+                }
+              ]);
+              succeeded++;
+            } catch (error) {
+              const rillError = mapPineconeError(error);
+              const result2 = {
+                succeeded,
+                failed: id,
+                error: rillError.message
+              };
+              const duration2 = Date.now() - startTime;
+              emitExtensionEvent3(ctx, {
+                event: "pinecone:upsert_batch",
+                subsystem: "extension:pinecone",
+                duration: duration2,
+                count: items.length,
+                succeeded
+              });
+              return result2;
+            }
+          }
+          const duration = Date.now() - startTime;
+          emitExtensionEvent3(ctx, {
+            event: "pinecone:upsert_batch",
+            subsystem: "extension:pinecone",
+            duration,
+            count: items.length,
+            succeeded
+          });
+          return { succeeded };
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          const rillError = mapPineconeError(error);
+          emitExtensionEvent3(ctx, {
+            event: "pinecone:error",
+            subsystem: "extension:pinecone",
+            error: rillError.message,
+            duration
+          });
+          throw rillError;
+        }
+      },
+      description: "Batch insert/update vectors",
+      returnType: "dict"
+    },
+    // IR-3: pinecone::search
+    search: {
+      params: [
+        { name: "vector", type: "vector" },
+        { name: "options", type: "dict", defaultValue: {} }
+      ],
+      fn: async (args, ctx) => {
+        checkDisposed2();
+        const vector = args[0];
+        const options = args[1] ?? {};
+        const k = typeof options["k"] === "number" ? options["k"] : 10;
+        const filter = options["filter"] ?? {};
+        const scoreThreshold = typeof options["score_threshold"] === "number" ? options["score_threshold"] : void 0;
+        const startTime = Date.now();
+        try {
+          const index = client.Index(factoryIndex);
+          const searchRequest = {
+            vector: Array.from(vector.data),
+            topK: k,
+            includeMetadata: true
+          };
+          if (Object.keys(filter).length > 0) {
+            searchRequest.filter = filter;
+          }
+          const response = await index.namespace(factoryNamespace).query(searchRequest);
+          const results = (response.matches ?? []).map((hit) => {
+            const metadata = {};
+            if (hit.metadata) {
+              for (const [key, value] of Object.entries(hit.metadata)) {
+                if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+                  metadata[key] = value;
+                } else {
+                  metadata[key] = String(value);
+                }
+              }
+            }
+            return {
+              id: hit.id,
+              score: hit.score ?? 0,
+              metadata
+            };
+          });
+          let filtered = results;
+          if (scoreThreshold !== void 0 && Array.isArray(results)) {
+            filtered = results.filter(
+              (r) => (r["score"] ?? 0) >= scoreThreshold
+            );
+          }
+          const duration = Date.now() - startTime;
+          emitExtensionEvent3(ctx, {
+            event: "pinecone:search",
+            subsystem: "extension:pinecone",
+            duration,
+            result_count: Array.isArray(filtered) ? filtered.length : 0,
+            k
+          });
+          return filtered;
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          const rillError = mapPineconeError(error);
+          emitExtensionEvent3(ctx, {
+            event: "pinecone:error",
+            subsystem: "extension:pinecone",
+            error: rillError.message,
+            duration
+          });
+          throw rillError;
+        }
+      },
+      description: "Search k nearest neighbors",
+      returnType: "list"
+    },
+    // IR-4: pinecone::get
+    get: {
+      params: [{ name: "id", type: "string" }],
+      fn: async (args, ctx) => {
+        checkDisposed2();
+        const id = args[0];
+        return withEventEmission(
+          ctx,
+          "pinecone",
+          "get",
+          { id },
+          async () => {
+            const index = client.Index(factoryIndex);
+            const response = await index.namespace(factoryNamespace).fetch([id]);
+            if (!response.records || response.records[id] === void 0) {
+              throw new RuntimeError4("RILL-R004", "pinecone: id not found");
+            }
+            const record = response.records[id];
+            const vectorData = record.values;
+            if (!vectorData || !Array.isArray(vectorData)) {
+              throw new RuntimeError4(
+                "RILL-R004",
+                "pinecone: invalid vector format"
+              );
+            }
+            const float32Data = new Float32Array(vectorData);
+            const vector = createVector(float32Data, factoryIndex);
+            return {
+              id,
+              vector,
+              metadata: record.metadata ?? {}
+            };
+          }
+        );
+      },
+      description: "Fetch vector by ID",
+      returnType: "dict"
+    },
+    // IR-5: pinecone::delete
+    delete: {
+      params: [{ name: "id", type: "string" }],
+      fn: async (args, ctx) => {
+        checkDisposed2();
+        const id = args[0];
+        return withEventEmission(
+          ctx,
+          "pinecone",
+          "delete",
+          { id },
+          async () => {
+            const index = client.Index(factoryIndex);
+            const ns = factoryNamespace || "";
+            await index.namespace(ns).deleteOne(id);
+            return {
+              id,
+              deleted: true
+            };
+          }
+        );
+      },
+      description: "Delete vector by ID",
+      returnType: "dict"
+    },
+    // IR-6: pinecone::delete_batch
+    delete_batch: {
+      params: [{ name: "ids", type: "list" }],
+      fn: async (args, ctx) => {
+        const startTime = Date.now();
+        try {
+          checkDisposed2();
+          const ids = args[0];
+          let succeeded = 0;
+          const index = client.Index(factoryIndex);
+          for (let i = 0; i < ids.length; i++) {
+            const id = ids[i];
+            try {
+              await index.namespace(factoryNamespace).deleteOne(id);
+              succeeded++;
+            } catch (error) {
+              const rillError = mapPineconeError(error);
+              const result2 = {
+                succeeded,
+                failed: id,
+                error: rillError.message
+              };
+              const duration2 = Date.now() - startTime;
+              emitExtensionEvent3(ctx, {
+                event: "pinecone:delete_batch",
+                subsystem: "extension:pinecone",
+                duration: duration2,
+                count: ids.length,
+                succeeded
+              });
+              return result2;
+            }
+          }
+          const duration = Date.now() - startTime;
+          emitExtensionEvent3(ctx, {
+            event: "pinecone:delete_batch",
+            subsystem: "extension:pinecone",
+            duration,
+            count: ids.length,
+            succeeded
+          });
+          return { succeeded };
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          const rillError = mapPineconeError(error);
+          emitExtensionEvent3(ctx, {
+            event: "pinecone:error",
+            subsystem: "extension:pinecone",
+            error: rillError.message,
+            duration
+          });
+          throw rillError;
+        }
+      },
+      description: "Batch delete vectors",
+      returnType: "dict"
+    },
+    // IR-7: pinecone::count
+    count: {
+      params: [],
+      fn: async (_args, ctx) => {
+        checkDisposed2();
+        return withEventEmission(
+          ctx,
+          "pinecone",
+          "count",
+          {},
+          async () => {
+            const index = client.Index(factoryIndex);
+            const stats = await index.describeIndexStats();
+            const count = stats.namespaces?.[factoryNamespace]?.recordCount ?? 0;
+            return count;
+          }
+        );
+      },
+      description: "Return total vector count in collection",
+      returnType: "number"
+    },
+    // IR-8: pinecone::create_collection
+    create_collection: {
+      params: [
+        { name: "name", type: "string" },
+        { name: "options", type: "dict", defaultValue: {} }
+      ],
+      fn: async (args, ctx) => {
+        checkDisposed2();
+        const name = args[0];
+        const options = args[1] ?? {};
+        const dimensions = options["dimensions"];
+        const distance = options["distance"] ?? "cosine";
+        if (!dimensions || typeof dimensions !== "number" || dimensions <= 0) {
+          throw new RuntimeError4(
+            "RILL-R004",
+            "pinecone: dimensions must be a positive integer"
+          );
+        }
+        return withEventEmission(
+          ctx,
+          "pinecone",
+          "create_collection",
+          { name },
+          async () => {
+            let pineconeMetric;
+            if (distance === "cosine") {
+              pineconeMetric = "cosine";
+            } else if (distance === "euclidean") {
+              pineconeMetric = "euclidean";
+            } else {
+              pineconeMetric = "dotproduct";
+            }
+            await client.createIndex({
+              name,
+              dimension: dimensions,
+              metric: pineconeMetric,
+              spec: {
+                serverless: {
+                  cloud: "aws",
+                  region: "us-east-1"
+                }
+              }
+            });
+            return {
+              name,
+              created: true
+            };
+          }
+        );
+      },
+      description: "Create new vector collection",
+      returnType: "dict"
+    },
+    // IR-9: pinecone::delete_collection
+    delete_collection: {
+      params: [{ name: "name", type: "string" }],
+      fn: async (args, ctx) => {
+        checkDisposed2();
+        const name = args[0];
+        return withEventEmission(
+          ctx,
+          "pinecone",
+          "delete_collection",
+          { name },
+          async () => {
+            await client.deleteIndex(name);
+            return {
+              name,
+              deleted: true
+            };
+          }
+        );
+      },
+      description: "Delete vector collection",
+      returnType: "dict"
+    },
+    // IR-10: pinecone::list_collections
+    list_collections: {
+      params: [],
+      fn: async (_args, ctx) => {
+        checkDisposed2();
+        return withEventEmission(
+          ctx,
+          "pinecone",
+          "list_collections",
+          {},
+          async () => {
+            const response = await client.listIndexes();
+            const names = response.indexes?.map((index) => index.name ?? "") ?? [];
+            return names;
+          }
+        );
+      },
+      description: "List all collection names",
+      returnType: "list"
+    },
+    // IR-11: pinecone::describe
+    describe: {
+      params: [],
+      fn: async (_args, ctx) => {
+        checkDisposed2();
+        return withEventEmission(
+          ctx,
+          "pinecone",
+          "describe",
+          { name: factoryIndex },
+          async () => {
+            const index = client.Index(factoryIndex);
+            const stats = await index.describeIndexStats();
+            const indexInfo = await client.describeIndex(factoryIndex);
+            const dimensions = stats.dimension ?? 0;
+            const count = stats.namespaces?.[factoryNamespace]?.recordCount ?? 0;
+            let distance = "cosine";
+            const metric = indexInfo.metric;
+            if (metric === "cosine") {
+              distance = "cosine";
+            } else if (metric === "euclidean") {
+              distance = "euclidean";
+            } else if (metric === "dotproduct") {
+              distance = "dot";
+            }
+            return {
+              name: factoryIndex,
+              count,
+              dimensions,
+              distance
+            };
+          }
+        );
+      },
+      description: "Describe configured collection",
+      returnType: "dict"
+    }
+  };
+  result.dispose = dispose2;
+  return result;
+}
+
+// src/index.ts
+var VERSION = "0.0.1";
+export {
+  VERSION,
+  createPineconeExtension
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rcrsr/rill-ext-pinecone",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "rill extension for Pinecone vector database integration",
   "license": "MIT",
   "author": "Andre Bremer",
@@ -17,10 +17,15 @@
     "scripting"
   ],
   "peerDependencies": {
-    "@rcrsr/rill": "^0.8.3"
+    "@rcrsr/rill": "^0.8.5"
   },
   "devDependencies": {
-    "@rcrsr/rill": "^0.8.3"
+    "@types/node": "^25.2.3",
+    "dts-bundle-generator": "^9.5.1",
+    "tsup": "^8.5.0",
+    "undici-types": "^7.21.0",
+    "@rcrsr/rill": "^0.8.5",
+    "@rcrsr/rill-ext-vector-shared": "^0.0.1"
   },
   "files": [
     "dist"
@@ -38,11 +43,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@pinecone-database/pinecone": "^3.0.3",
-    "@rcrsr/rill-ext-vector-shared": "^0.0.1"
+    "@pinecone-database/pinecone": "^3.0.3"
   },
   "scripts": {
-    "build": "tsc --build",
+    "build": "tsup && dts-bundle-generator --config dts-bundle-generator.config.cjs",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
     "lint": "eslint --config ../../../eslint.config.js src/",

package/dist/factory.d.ts

@@ -1,26 +0,0 @@
-/**
- * Extension factory for Pinecone vector database integration.
- * Creates extension instance with config validation and SDK lifecycle management.
- */
-import { type ExtensionResult } from '@rcrsr/rill';
-import type { PineconeConfig } from './types.js';
-/**
- * Create Pinecone extension instance.
- * Validates configuration and returns host functions with cleanup.
- *
- * @param config - Extension configuration
- * @returns ExtensionResult with 11 vector database functions and dispose
- * @throws Error for invalid configuration (AC-10)
- *
- * @example
- * ```typescript
- * const ext = createPineconeExtension({
- *   apiKey: 'your-api-key',
- *   index: 'my-index',
- * });
- * // Use with rill runtime...
- * await ext.dispose();
- * ```
- */
-export declare function createPineconeExtension(config: PineconeConfig): ExtensionResult;
-//# sourceMappingURL=factory.d.ts.map