@kb-labs/core-platform 1.0.0

package/dist/noop/adapters/index.cjs

@@ -0,0 +1,656 @@
+'use strict';
+
+// src/noop/adapters/analytics.ts
+var NoOpAnalytics = class {
+  async track(_event, _properties) {
+  }
+  async identify(_userId, _traits) {
+  }
+  async flush() {
+  }
+};
+
+// src/noop/adapters/vector-store.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    return 0;
+  }
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    const aVal = a[i] ?? 0;
+    const bVal = b[i] ?? 0;
+    dotProduct += aVal * bVal;
+    normA += aVal * aVal;
+    normB += bVal * bVal;
+  }
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  return denominator === 0 ? 0 : dotProduct / denominator;
+}
+function matchesFilter(record, filter) {
+  const value = record.metadata?.[filter.field];
+  switch (filter.operator) {
+    case "eq":
+      return value === filter.value;
+    case "ne":
+      return value !== filter.value;
+    case "gt":
+      return typeof value === "number" && value > filter.value;
+    case "gte":
+      return typeof value === "number" && value >= filter.value;
+    case "lt":
+      return typeof value === "number" && value < filter.value;
+    case "lte":
+      return typeof value === "number" && value <= filter.value;
+    case "in":
+      return Array.isArray(filter.value) && filter.value.includes(value);
+    case "nin":
+      return Array.isArray(filter.value) && !filter.value.includes(value);
+    default:
+      return true;
+  }
+}
+var MemoryVectorStore = class {
+  vectors = /* @__PURE__ */ new Map();
+  async search(query, limit, filter) {
+    const results = [];
+    for (const record of this.vectors.values()) {
+      if (filter && !matchesFilter(record, filter)) {
+        continue;
+      }
+      const score = cosineSimilarity(query, record.vector);
+      results.push({
+        id: record.id,
+        score,
+        metadata: record.metadata
+      });
+    }
+    return results.sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+  async upsert(vectors) {
+    for (const vector of vectors) {
+      this.vectors.set(vector.id, vector);
+    }
+  }
+  async delete(ids) {
+    for (const id of ids) {
+      this.vectors.delete(id);
+    }
+  }
+  async count() {
+    return this.vectors.size;
+  }
+};
+
+// src/noop/adapters/llm.ts
+var MockLLM = class {
+  getProtocolCapabilities() {
+    return {
+      cache: { supported: false },
+      stream: { supported: true }
+    };
+  }
+  async complete(prompt, options) {
+    const content = `[Mock LLM Response] Received prompt of ${prompt.length} characters.`;
+    return {
+      content,
+      usage: {
+        promptTokens: Math.ceil(prompt.length / 4),
+        completionTokens: Math.ceil(content.length / 4)
+      },
+      model: options?.model ?? "mock-model"
+    };
+  }
+  async *stream(prompt, options) {
+    const response = `[Mock LLM Stream] Received prompt of ${prompt.length} characters.`;
+    const words = response.split(" ");
+    for (const word of words) {
+      yield word + " ";
+      await new Promise((resolve) => {
+        setTimeout(resolve, 50);
+      });
+    }
+  }
+};
+
+// src/noop/adapters/embeddings.ts
+var MockEmbeddings = class {
+  dimensions = 1536;
+  /**
+   * Simple hash function for deterministic embedding generation.
+   */
+  hash(text) {
+    let hash = 0;
+    for (let i = 0; i < text.length; i++) {
+      const char = text.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return hash;
+  }
+  /**
+   * Generate a deterministic vector based on text.
+   */
+  generateVector(text) {
+    const seed = this.hash(text);
+    const vector = [];
+    for (let i = 0; i < this.dimensions; i++) {
+      const value = Math.sin(seed * (i + 1)) * 0.5;
+      vector.push(value);
+    }
+    const magnitude = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+    return vector.map((v) => v / magnitude);
+  }
+  async embed(text) {
+    return this.generateVector(text);
+  }
+  async embedBatch(texts) {
+    return texts.map((text) => this.generateVector(text));
+  }
+  /**
+   * Get the dimensions of the embeddings.
+   * This method is needed for IPC/Unix Socket transport to access the dimensions property.
+   */
+  async getDimensions() {
+    return this.dimensions;
+  }
+};
+
+// src/noop/adapters/cache.ts
+var MemoryCache = class {
+  store = /* @__PURE__ */ new Map();
+  sortedSets = /* @__PURE__ */ new Map();
+  async get(key) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (entry.expiresAt !== null && Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  async set(key, value, ttl) {
+    const expiresAt = ttl ? Date.now() + ttl : null;
+    this.store.set(key, { value, expiresAt });
+  }
+  async delete(key) {
+    this.store.delete(key);
+  }
+  async clear(pattern) {
+    if (!pattern) {
+      this.store.clear();
+      return;
+    }
+    const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+    for (const key of this.store.keys()) {
+      if (regex.test(key)) {
+        this.store.delete(key);
+      }
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Sorted Set Operations
+  // ═══════════════════════════════════════════════════════════════════════
+  async zadd(key, score, member) {
+    let set = this.sortedSets.get(key);
+    if (!set) {
+      set = [];
+      this.sortedSets.set(key, set);
+    }
+    const existingIndex = set.findIndex((m) => m.member === member);
+    if (existingIndex !== -1) {
+      set.splice(existingIndex, 1);
+    }
+    set.push({ score, member });
+    set.sort((a, b) => a.score - b.score);
+  }
+  async zrangebyscore(key, min, max) {
+    const set = this.sortedSets.get(key);
+    if (!set) {
+      return [];
+    }
+    return set.filter((m) => m.score >= min && m.score <= max).map((m) => m.member);
+  }
+  async zrem(key, member) {
+    const set = this.sortedSets.get(key);
+    if (!set) {
+      return;
+    }
+    const index = set.findIndex((m) => m.member === member);
+    if (index !== -1) {
+      set.splice(index, 1);
+    }
+    if (set.length === 0) {
+      this.sortedSets.delete(key);
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Atomic Operations
+  // ═══════════════════════════════════════════════════════════════════════
+  async setIfNotExists(key, value, ttl) {
+    if (this.store.has(key)) {
+      return false;
+    }
+    await this.set(key, value, ttl);
+    return true;
+  }
+  /**
+   * Get the current number of entries (for testing).
+   */
+  get size() {
+    return this.store.size;
+  }
+};
+
+// src/noop/adapters/config.ts
+var NoOpConfig = class {
+  async getConfig(_productId, _profileId) {
+    return void 0;
+  }
+  async getRawConfig() {
+    return void 0;
+  }
+};
+
+// src/noop/adapters/storage.ts
+var MemoryStorage = class {
+  store = /* @__PURE__ */ new Map();
+  async read(path) {
+    return this.store.get(path) ?? null;
+  }
+  async write(path, data) {
+    this.store.set(path, data);
+  }
+  async delete(path) {
+    this.store.delete(path);
+  }
+  async list(prefix) {
+    const results = [];
+    for (const key of this.store.keys()) {
+      if (key.startsWith(prefix)) {
+        results.push(key);
+      }
+    }
+    return results.sort();
+  }
+  async exists(path) {
+    return this.store.has(path);
+  }
+  /**
+   * Get file metadata.
+   * Optional method - implements IStorage.stat().
+   */
+  async stat(path) {
+    const data = this.store.get(path);
+    if (!data) {
+      return null;
+    }
+    return {
+      path,
+      size: data.byteLength,
+      lastModified: (/* @__PURE__ */ new Date()).toISOString(),
+      contentType: "application/octet-stream"
+    };
+  }
+  /**
+   * Copy file.
+   * Optional method - implements IStorage.copy().
+   */
+  async copy(sourcePath, destPath) {
+    const data = this.store.get(sourcePath);
+    if (!data) {
+      throw new Error(`Source file not found: ${sourcePath}`);
+    }
+    this.store.set(destPath, Buffer.from(data));
+  }
+  /**
+   * Move file.
+   * Optional method - implements IStorage.move().
+   */
+  async move(sourcePath, destPath) {
+    const data = this.store.get(sourcePath);
+    if (!data) {
+      throw new Error(`Source file not found: ${sourcePath}`);
+    }
+    this.store.set(destPath, data);
+    this.store.delete(sourcePath);
+  }
+  /**
+   * List files with metadata.
+   * Optional method - implements IStorage.listWithMetadata().
+   */
+  async listWithMetadata(prefix) {
+    const results = [];
+    for (const [path, data] of this.store.entries()) {
+      if (path.startsWith(prefix)) {
+        results.push({
+          path,
+          size: data.byteLength,
+          lastModified: (/* @__PURE__ */ new Date()).toISOString(),
+          contentType: "application/octet-stream"
+        });
+      }
+    }
+    return results.sort((a, b) => a.path.localeCompare(b.path));
+  }
+  /**
+   * Get the current number of stored files (for testing).
+   */
+  get size() {
+    return this.store.size;
+  }
+  /**
+   * Clear all storage (for testing).
+   */
+  clear() {
+    this.store.clear();
+  }
+};
+
+// src/noop/adapters/logger.ts
+var ConsoleLogger = class _ConsoleLogger {
+  bindings;
+  level;
+  constructor(bindings = {}, level) {
+    this.bindings = bindings;
+    this.level = level ?? process.env.KB_LOG_LEVEL ?? "info";
+  }
+  shouldLog(messageLevel) {
+    const levels = {
+      silent: 0,
+      error: 1,
+      warn: 2,
+      info: 3,
+      debug: 4,
+      trace: 5
+    };
+    const currentLevel = levels[this.level] ?? 3;
+    const targetLevel = levels[messageLevel] ?? 3;
+    return targetLevel <= currentLevel;
+  }
+  formatMeta(meta) {
+    const combined = { ...this.bindings, ...meta };
+    if (Object.keys(combined).length === 0) {
+      return "";
+    }
+    return " " + JSON.stringify(combined);
+  }
+  info(message, meta) {
+    if (this.shouldLog("info")) {
+      console.log(`[INFO] ${message}${this.formatMeta(meta)}`);
+    }
+  }
+  warn(message, meta) {
+    if (this.shouldLog("warn")) {
+      console.warn(`[WARN] ${message}${this.formatMeta(meta)}`);
+    }
+  }
+  error(message, error, meta) {
+    if (this.shouldLog("error")) {
+      const errorMeta = error ? { ...meta, error: { message: error.message, stack: error.stack } } : meta;
+      console.error(`[ERROR] ${message}${this.formatMeta(errorMeta)}`);
+    }
+  }
+  fatal(message, error, meta) {
+    if (this.shouldLog("error")) {
+      const errorMeta = error ? { ...meta, error: { message: error.message, stack: error.stack } } : meta;
+      console.error(`[FATAL] ${message}${this.formatMeta(errorMeta)}`);
+    }
+  }
+  debug(message, meta) {
+    if (this.shouldLog("debug")) {
+      console.debug(`[DEBUG] ${message}${this.formatMeta(meta)}`);
+    }
+  }
+  trace(message, meta) {
+    if (this.shouldLog("trace")) {
+      console.debug(`[TRACE] ${message}${this.formatMeta(meta)}`);
+    }
+  }
+  child(bindings) {
+    return new _ConsoleLogger({ ...this.bindings, ...bindings }, this.level);
+  }
+};
+var NoOpLogger = class {
+  info(_message, _meta) {
+  }
+  warn(_message, _meta) {
+  }
+  error(_message, _error, _meta) {
+  }
+  fatal(_message, _error, _meta) {
+  }
+  debug(_message, _meta) {
+  }
+  trace(_message, _meta) {
+  }
+  child(_bindings) {
+    return this;
+  }
+};
+
+// src/noop/adapters/event-bus.ts
+var MemoryEventBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  async publish(topic, event) {
+    const topicHandlers = this.handlers.get(topic);
+    if (!topicHandlers) {
+      return;
+    }
+    const promises = Array.from(topicHandlers).map(
+      (handler) => handler(event).catch((err) => {
+        console.error(`[EventBus] Handler error for topic "${topic}":`, err);
+      })
+    );
+    await Promise.all(promises);
+  }
+  subscribe(topic, handler) {
+    let topicHandlers = this.handlers.get(topic);
+    if (!topicHandlers) {
+      topicHandlers = /* @__PURE__ */ new Set();
+      this.handlers.set(topic, topicHandlers);
+    }
+    topicHandlers.add(handler);
+    return () => {
+      topicHandlers.delete(handler);
+      if (topicHandlers.size === 0) {
+        this.handlers.delete(topic);
+      }
+    };
+  }
+  /**
+   * Get the number of topics with subscribers (for testing).
+   */
+  get topicCount() {
+    return this.handlers.size;
+  }
+  /**
+   * Get the total number of handlers across all topics (for testing).
+   */
+  get handlerCount() {
+    let count = 0;
+    for (const handlers of this.handlers.values()) {
+      count += handlers.size;
+    }
+    return count;
+  }
+  /**
+   * Clear all subscriptions (for testing).
+   */
+  clear() {
+    this.handlers.clear();
+  }
+};
+var NoOpEventBus = class {
+  async publish(_topic, _event) {
+  }
+  subscribe(_topic, _handler) {
+    return () => {
+    };
+  }
+};
+
+// src/noop/adapters/invoke.ts
+var NoOpInvoke = class {
+  async call(_request) {
+    return {
+      success: false,
+      error: "Invoke not configured. Inter-plugin calls are not available."
+    };
+  }
+  async isAvailable(_pluginId, _command) {
+    return false;
+  }
+};
+
+// src/noop/adapters/artifacts.ts
+var MemoryArtifacts = class {
+  store = /* @__PURE__ */ new Map();
+  async write(key, data, options) {
+    const now = /* @__PURE__ */ new Date();
+    const meta = {
+      key,
+      contentType: options?.contentType ?? "application/json",
+      size: JSON.stringify(data).length,
+      createdAt: this.store.get(key)?.meta.createdAt ?? now,
+      updatedAt: now,
+      metadata: options?.metadata
+    };
+    this.store.set(key, { data, meta });
+  }
+  async read(key) {
+    const entry = this.store.get(key);
+    return entry ? entry.data : null;
+  }
+  async exists(key) {
+    return this.store.has(key);
+  }
+  async delete(key) {
+    this.store.delete(key);
+  }
+  async list(prefix) {
+    const results = [];
+    for (const [key, entry] of this.store) {
+      if (key.startsWith(prefix)) {
+        results.push(entry.meta);
+      }
+    }
+    return results;
+  }
+  async getMeta(key) {
+    const entry = this.store.get(key);
+    return entry?.meta ?? null;
+  }
+};
+
+// src/noop/adapters/database.ts
+var NoOpSQLDatabase = class {
+  async query(_sql, _params) {
+    throw new Error("SQL database not configured");
+  }
+  async transaction() {
+    throw new Error("SQL database not configured");
+  }
+  async close() {
+  }
+};
+var NoOpDocumentDatabase = class {
+  async find(_collection, _filter, _options) {
+    throw new Error("Document database not configured");
+  }
+  async findById(_collection, _id) {
+    throw new Error("Document database not configured");
+  }
+  async insertOne(_collection, _document) {
+    throw new Error("Document database not configured");
+  }
+  async updateMany(_collection, _filter, _update) {
+    throw new Error("Document database not configured");
+  }
+  async updateById(_collection, _id, _update) {
+    throw new Error("Document database not configured");
+  }
+  async deleteMany(_collection, _filter) {
+    throw new Error("Document database not configured");
+  }
+  async deleteById(_collection, _id) {
+    throw new Error("Document database not configured");
+  }
+  async count(_collection, _filter) {
+    throw new Error("Document database not configured");
+  }
+  async close() {
+  }
+};
+var NoOpKVDatabase = class {
+  async get(_key) {
+    throw new Error("Key-value database not configured");
+  }
+  async set(_key, _value, _ttlMs) {
+    throw new Error("Key-value database not configured");
+  }
+  async delete(_key) {
+    throw new Error("Key-value database not configured");
+  }
+  async exists(_key) {
+    throw new Error("Key-value database not configured");
+  }
+  async keys(_pattern) {
+    throw new Error("Key-value database not configured");
+  }
+  async close() {
+  }
+};
+var NoOpTimeSeriesDatabase = class {
+  async write(_metric, _point) {
+    throw new Error("Time-series database not configured");
+  }
+  async writeBatch(_metric, _points) {
+    throw new Error("Time-series database not configured");
+  }
+  async query(_metric, _startTime, _endTime, _tags) {
+    throw new Error("Time-series database not configured");
+  }
+  async close() {
+  }
+};
+var NoOpDatabaseProvider = class {
+  async getSQLDatabase(_name) {
+    return new NoOpSQLDatabase();
+  }
+  async getDocumentDatabase(_name) {
+    return new NoOpDocumentDatabase();
+  }
+  async getKeyValueDatabase(_name) {
+    return new NoOpKVDatabase();
+  }
+  async getTimeSeriesDatabase(_name) {
+    return new NoOpTimeSeriesDatabase();
+  }
+  async close() {
+  }
+};
+
+exports.ConsoleLogger = ConsoleLogger;
+exports.MemoryArtifacts = MemoryArtifacts;
+exports.MemoryCache = MemoryCache;
+exports.MemoryEventBus = MemoryEventBus;
+exports.MemoryStorage = MemoryStorage;
+exports.MemoryVectorStore = MemoryVectorStore;
+exports.MockEmbeddings = MockEmbeddings;
+exports.MockLLM = MockLLM;
+exports.NoOpAnalytics = NoOpAnalytics;
+exports.NoOpConfig = NoOpConfig;
+exports.NoOpDatabaseProvider = NoOpDatabaseProvider;
+exports.NoOpDocumentDatabase = NoOpDocumentDatabase;
+exports.NoOpEventBus = NoOpEventBus;
+exports.NoOpInvoke = NoOpInvoke;
+exports.NoOpKVDatabase = NoOpKVDatabase;
+exports.NoOpLogger = NoOpLogger;
+exports.NoOpSQLDatabase = NoOpSQLDatabase;
+exports.NoOpTimeSeriesDatabase = NoOpTimeSeriesDatabase;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map