@kb-labs/core-platform 1.0.0

package/dist/noop/index.js

@@ -0,0 +1,787 @@
+// 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/noop-platform.ts
+var noOpLogReader = {
+  query: async () => ({ logs: [], total: 0, hasMore: false, source: "buffer" }),
+  getById: async () => null,
+  search: async () => ({ logs: [], total: 0, hasMore: false }),
+  subscribe: () => () => {
+  },
+  getStats: async () => ({}),
+  getCapabilities: () => ({
+    hasBuffer: false,
+    hasPersistence: false,
+    hasSearch: false,
+    hasStreaming: false
+  })
+};
+function createNoOpPlatform() {
+  return {
+    logger: new NoOpLogger(),
+    llm: new MockLLM(),
+    cache: new MemoryCache(),
+    embeddings: new MockEmbeddings(),
+    vectorStore: new MemoryVectorStore(),
+    storage: new MemoryStorage(),
+    analytics: new NoOpAnalytics(),
+    eventBus: new NoOpEventBus(),
+    logs: noOpLogReader
+  };
+}
+
+// src/noop/core/workflow.ts
+var NoOpWorkflowEngine = class {
+  async execute(_workflowId, _input, _options) {
+    throw new Error(
+      "Workflow engine not configured. Initialize platform with core-runtime."
+    );
+  }
+  async getStatus(_runId) {
+    throw new Error(
+      "Workflow engine not configured. Initialize platform with core-runtime."
+    );
+  }
+  async cancel(_runId) {
+    throw new Error(
+      "Workflow engine not configured. Initialize platform with core-runtime."
+    );
+  }
+  async retry(_runId, _fromStep) {
+    throw new Error(
+      "Workflow engine not configured. Initialize platform with core-runtime."
+    );
+  }
+  async list(_filter) {
+    throw new Error(
+      "Workflow engine not configured. Initialize platform with core-runtime."
+    );
+  }
+};
+
+// src/noop/core/jobs.ts
+var NoOpJobScheduler = class {
+  jobs = /* @__PURE__ */ new Map();
+  idCounter = 0;
+  async submit(job) {
+    const id = `noop-job-${++this.idCounter}`;
+    const handle = {
+      id,
+      type: job.type,
+      tenantId: job.tenantId ?? "default",
+      status: "completed",
+      createdAt: /* @__PURE__ */ new Date(),
+      startedAt: /* @__PURE__ */ new Date(),
+      completedAt: /* @__PURE__ */ new Date()
+    };
+    this.jobs.set(id, handle);
+    return handle;
+  }
+  async schedule(job, _schedule) {
+    return this.submit(job);
+  }
+  async cancel(jobId) {
+    const job = this.jobs.get(jobId);
+    if (!job) {
+      return false;
+    }
+    job.status = "cancelled";
+    return true;
+  }
+  async getStatus(jobId) {
+    return this.jobs.get(jobId) ?? null;
+  }
+  async list(filter) {
+    let results = Array.from(this.jobs.values());
+    if (filter?.type) {
+      results = results.filter((j) => j.type === filter.type);
+    }
+    if (filter?.status) {
+      results = results.filter((j) => j.status === filter.status);
+    }
+    if (filter?.tenantId) {
+      results = results.filter((j) => j.tenantId === filter.tenantId);
+    }
+    return results;
+  }
+  /**
+   * Clear all jobs (for testing).
+   */
+  clear() {
+    this.jobs.clear();
+    this.idCounter = 0;
+  }
+};
+
+// src/noop/core/cron.ts
+var NoOpCronManager = class {
+  cronJobs = /* @__PURE__ */ new Map();
+  register(id, schedule, handler) {
+    this.cronJobs.set(id, {
+      id,
+      schedule,
+      handler,
+      status: "active",
+      runCount: 0
+    });
+  }
+  unregister(id) {
+    this.cronJobs.delete(id);
+  }
+  list() {
+    return Array.from(this.cronJobs.values()).map((entry) => ({
+      id: entry.id,
+      schedule: entry.schedule,
+      status: entry.status,
+      lastRun: entry.lastRun,
+      nextRun: void 0,
+      // NoOp doesn't calculate next run
+      runCount: entry.runCount
+    }));
+  }
+  async trigger(id) {
+    const entry = this.cronJobs.get(id);
+    if (!entry) {
+      throw new Error(`Cron job not found: ${id}`);
+    }
+    if (entry.status === "paused") {
+      throw new Error(`Cron job is paused: ${id}`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    await entry.handler({
+      jobId: id,
+      scheduledAt: now,
+      executedAt: now,
+      runCount: entry.runCount + 1
+    });
+    entry.lastRun = now;
+    entry.runCount++;
+  }
+  pause(id) {
+    const entry = this.cronJobs.get(id);
+    if (entry) {
+      entry.status = "paused";
+    }
+  }
+  resume(id) {
+    const entry = this.cronJobs.get(id);
+    if (entry) {
+      entry.status = "active";
+    }
+  }
+  /**
+   * Clear all cron jobs (for testing).
+   */
+  clear() {
+    this.cronJobs.clear();
+  }
+};
+
+// src/noop/core/resources.ts
+var UNLIMITED_QUOTAS = {
+  maxConcurrentWorkflows: Number.MAX_SAFE_INTEGER,
+  maxConcurrentJobs: Number.MAX_SAFE_INTEGER,
+  maxQueuedJobs: Number.MAX_SAFE_INTEGER,
+  apiRequestsPerMinute: Number.MAX_SAFE_INTEGER,
+  llmTokensPerDay: Number.MAX_SAFE_INTEGER,
+  storageBytes: Number.MAX_SAFE_INTEGER
+};
+var NoOpResourceManager = class {
+  quotas = /* @__PURE__ */ new Map();
+  slots = /* @__PURE__ */ new Map();
+  idCounter = 0;
+  async acquireSlot(resource, tenantId, timeout) {
+    const slot = {
+      id: `noop-slot-${++this.idCounter}`,
+      resource,
+      tenantId,
+      acquiredAt: /* @__PURE__ */ new Date(),
+      expiresAt: timeout ? new Date(Date.now() + timeout) : void 0
+    };
+    this.slots.set(slot.id, slot);
+    return slot;
+  }
+  async releaseSlot(slot) {
+    this.slots.delete(slot.id);
+  }
+  async getAvailability(resource, tenantId) {
+    const usedSlots = Array.from(this.slots.values()).filter(
+      (s) => s.resource === resource && (!tenantId || s.tenantId === tenantId)
+    );
+    return {
+      resource,
+      total: Number.MAX_SAFE_INTEGER,
+      used: usedSlots.length,
+      available: Number.MAX_SAFE_INTEGER,
+      queueLength: 0
+    };
+  }
+  async setQuota(tenantId, quotas) {
+    const existing = this.quotas.get(tenantId) ?? { ...UNLIMITED_QUOTAS };
+    this.quotas.set(tenantId, { ...existing, ...quotas });
+  }
+  async getQuota(tenantId) {
+    return this.quotas.get(tenantId) ?? { ...UNLIMITED_QUOTAS };
+  }
+  /**
+   * Get the current number of active slots (for testing).
+   */
+  get activeSlotCount() {
+    return this.slots.size;
+  }
+  /**
+   * Clear all slots and quotas (for testing).
+   */
+  clear() {
+    this.slots.clear();
+    this.quotas.clear();
+    this.idCounter = 0;
+  }
+};
+
+export { ConsoleLogger, MemoryArtifacts, MemoryCache, MemoryEventBus, MemoryStorage, MemoryVectorStore, MockEmbeddings, MockLLM, NoOpAnalytics, NoOpConfig, NoOpCronManager, NoOpEventBus, NoOpInvoke, NoOpJobScheduler, NoOpLogger, NoOpResourceManager, NoOpWorkflowEngine, createNoOpPlatform };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map