@simulatte/doppler 0.1.8 → 0.2.0

package/src/adapters/adapter-registry.d.ts

@@ -1,192 +0,0 @@
-/**
- * Local Adapter Registry
- *
- * Persists adapter metadata to OPFS/IndexedDB for offline discovery.
- * Tracks available adapters without loading full weights into memory.
- *
- * @module adapters/adapter-registry
- */
-
-import type { AdapterManifest, AdapterMetadata } from './adapter-manifest.js';
-import type { LoRAModuleName } from '../inference/pipelines/text/lora-types.js';
-
-/**
- * Registry entry for a stored adapter.
- */
-export interface AdapterRegistryEntry {
-  /** Unique adapter ID */
-  id: string;
-  /** Human-readable name */
-  name: string;
-  /** Version string */
-  version: string;
-  /** Base model this adapter is for */
-  baseModel: string;
-  /** LoRA rank */
-  rank: number;
-  /** LoRA alpha */
-  alpha: number;
-  /** Target modules */
-  targetModules: LoRAModuleName[];
-  /** Storage location type */
-  storageType: 'opfs' | 'indexeddb' | 'url';
-  /** Path to manifest */
-  manifestPath: string;
-  /** Path to weights (if separate from manifest) */
-  weightsPath?: string;
-  /** Size of weights in bytes */
-  weightsSize?: number;
-  /** SHA-256 checksum */
-  checksum?: string;
-  /** Additional metadata */
-  metadata?: AdapterMetadata;
-  /** Registration timestamp */
-  registeredAt: number;
-  /** Last access timestamp */
-  lastAccessedAt: number;
-}
-
-/**
- * Query options for listing adapters.
- */
-export interface AdapterQueryOptions {
-  /** Filter by base model */
-  baseModel?: string;
-  /** Filter by target modules (adapter must include all) */
-  targetModules?: LoRAModuleName[];
-  /** Filter by tags (adapter must include at least one) */
-  tags?: string[];
-  /** Sort field */
-  sortBy?: 'name' | 'registeredAt' | 'lastAccessedAt';
-  /** Sort direction */
-  sortOrder?: 'asc' | 'desc';
-  /** Maximum number of results */
-  limit?: number;
-  /** Offset for pagination */
-  offset?: number;
-}
-
-/**
- * Registry storage interface.
- */
-export interface RegistryStorage {
-  /** Get all entries */
-  getAll(): Promise<AdapterRegistryEntry[]>;
-  /** Get entry by ID */
-  get(id: string): Promise<AdapterRegistryEntry | null>;
-  /** Set entry */
-  set(id: string, entry: AdapterRegistryEntry): Promise<void>;
-  /** Delete entry */
-  delete(id: string): Promise<boolean>;
-  /** Clear all entries */
-  clear(): Promise<void>;
-}
-
-/**
- * Local registry for tracking available LoRA adapters.
- */
-export declare class AdapterRegistry {
-  constructor(storage?: RegistryStorage);
-
-  /**
-   * Registers an adapter in the registry.
-   */
-  register(
-    manifest: AdapterManifest,
-    location: {
-      storageType: 'opfs' | 'indexeddb' | 'url';
-      manifestPath: string;
-      weightsPath?: string;
-    }
-  ): Promise<AdapterRegistryEntry>;
-
-  /**
-   * Registers an adapter from a URL (fetches manifest first).
-   */
-  registerFromUrl(url: string): Promise<AdapterRegistryEntry>;
-
-  /**
-   * Unregisters an adapter from the registry.
-   */
-  unregister(id: string): Promise<boolean>;
-
-  /**
-   * Clears all entries from the registry.
-   */
-  clear(): Promise<void>;
-
-  /**
-   * Gets an adapter entry by ID.
-   */
-  get(id: string): Promise<AdapterRegistryEntry | null>;
-
-  /**
-   * Lists adapters matching the given query.
-   */
-  list(options?: AdapterQueryOptions): Promise<AdapterRegistryEntry[]>;
-
-  /**
-   * Gets count of registered adapters.
-   */
-  count(options?: Omit<AdapterQueryOptions, 'sortBy' | 'sortOrder' | 'limit' | 'offset'>): Promise<number>;
-
-  /**
-   * Checks if an adapter is registered.
-   */
-  has(id: string): Promise<boolean>;
-
-  /**
-   * Gets all unique base models in the registry.
-   */
-  getBaseModels(): Promise<string[]>;
-
-  /**
-   * Gets all unique tags in the registry.
-   */
-  getTags(): Promise<string[]>;
-
-  /**
-   * Updates metadata for an adapter.
-   */
-  updateMetadata(id: string, metadata: Partial<AdapterMetadata>): Promise<AdapterRegistryEntry | null>;
-
-  /**
-   * Updates storage location for an adapter.
-   */
-  updateLocation(
-    id: string,
-    location: {
-      storageType?: 'opfs' | 'indexeddb' | 'url';
-      manifestPath?: string;
-      weightsPath?: string;
-    }
-  ): Promise<AdapterRegistryEntry | null>;
-
-  /**
-   * Exports all registry entries as JSON.
-   */
-  exportToJSON(): Promise<string>;
-
-  /**
-   * Imports registry entries from JSON.
-   */
-  importFromJSON(
-    json: string,
-    options?: { overwrite?: boolean; merge?: boolean }
-  ): Promise<{ imported: number; skipped: number; errors: string[] }>;
-}
-
-/**
- * Gets the default adapter registry instance.
- */
-export declare function getAdapterRegistry(): AdapterRegistry;
-
-/**
- * Resets the default adapter registry (useful for testing).
- */
-export declare function resetAdapterRegistry(): void;
-
-/**
- * Creates an in-memory registry for testing.
- */
-export declare function createMemoryRegistry(): AdapterRegistry;

package/src/adapters/adapter-registry.js

@@ -1,477 +0,0 @@
-
-
-import { validateManifest } from './adapter-manifest.js';
-import { DEFAULT_ADAPTER_REGISTRY_CONFIG } from '../config/schema/index.js';
-
-// ============================================================================
-// IndexedDB Storage Implementation
-// ============================================================================
-
-const { dbName: DB_NAME, dbVersion: DB_VERSION, storeName: STORE_NAME } = DEFAULT_ADAPTER_REGISTRY_CONFIG;
-
-function isNodeRuntime() {
-  return typeof process !== 'undefined'
-    && !!process.versions?.node
-    && typeof window === 'undefined';
-}
-
-
-class IndexedDBStorage {
-  #db = null;
-  #initPromise = null;
-
-  async #init() {
-    if (this.#db) return;
-
-    if (this.#initPromise) {
-      await this.#initPromise;
-      return;
-    }
-
-    this.#initPromise = new Promise((resolve, reject) => {
-      const request = indexedDB.open(DB_NAME, DB_VERSION);
-
-      request.onerror = () => {
-        reject(new Error(`Failed to open IndexedDB: ${request.error?.message}`));
-      };
-
-      request.onsuccess = () => {
-        this.#db = request.result;
-        resolve();
-      };
-
-      request.onupgradeneeded = (event) => {
-        const db = event.target.result;
-
-        if (!db.objectStoreNames.contains(STORE_NAME)) {
-          const store = db.createObjectStore(STORE_NAME, { keyPath: 'id' });
-          store.createIndex('baseModel', 'baseModel', { unique: false });
-          store.createIndex('registeredAt', 'registeredAt', { unique: false });
-          store.createIndex('lastAccessedAt', 'lastAccessedAt', { unique: false });
-        }
-      };
-    });
-
-    await this.#initPromise;
-  }
-
-  async getAll() {
-    await this.#init();
-
-    return new Promise((resolve, reject) => {
-      const tx = this.#db.transaction(STORE_NAME, 'readonly');
-      const store = tx.objectStore(STORE_NAME);
-      const request = store.getAll();
-
-      request.onsuccess = () => resolve(request.result || []);
-      request.onerror = () => reject(new Error(`Failed to get all: ${request.error?.message}`));
-    });
-  }
-
-  async get(id) {
-    await this.#init();
-
-    return new Promise((resolve, reject) => {
-      const tx = this.#db.transaction(STORE_NAME, 'readonly');
-      const store = tx.objectStore(STORE_NAME);
-      const request = store.get(id);
-
-      request.onsuccess = () => resolve(request.result || null);
-      request.onerror = () => reject(new Error(`Failed to get ${id}: ${request.error?.message}`));
-    });
-  }
-
-  async set(id, entry) {
-    await this.#init();
-
-    return new Promise((resolve, reject) => {
-      const tx = this.#db.transaction(STORE_NAME, 'readwrite');
-      const store = tx.objectStore(STORE_NAME);
-      const request = store.put(entry);
-
-      request.onsuccess = () => resolve();
-      request.onerror = () => reject(new Error(`Failed to set ${id}: ${request.error?.message}`));
-    });
-  }
-
-  async delete(id) {
-    await this.#init();
-
-    const existing = await this.get(id);
-    if (!existing) return false;
-
-    return new Promise((resolve, reject) => {
-      const tx = this.#db.transaction(STORE_NAME, 'readwrite');
-      const store = tx.objectStore(STORE_NAME);
-      const request = store.delete(id);
-
-      request.onsuccess = () => resolve(true);
-      request.onerror = () => reject(new Error(`Failed to delete ${id}: ${request.error?.message}`));
-    });
-  }
-
-  async clear() {
-    await this.#init();
-
-    return new Promise((resolve, reject) => {
-      const tx = this.#db.transaction(STORE_NAME, 'readwrite');
-      const store = tx.objectStore(STORE_NAME);
-      const request = store.clear();
-
-      request.onsuccess = () => resolve();
-      request.onerror = () => reject(new Error(`Failed to clear: ${request.error?.message}`));
-    });
-  }
-}
-
-// ============================================================================
-// In-Memory Storage (for Node.js or testing)
-// ============================================================================
-
-
-class MemoryStorage {
-  #data = new Map();
-
-  async getAll() {
-    return [...this.#data.values()];
-  }
-
-  async get(id) {
-    return this.#data.get(id) || null;
-  }
-
-  async set(id, entry) {
-    this.#data.set(id, entry);
-  }
-
-  async delete(id) {
-    return this.#data.delete(id);
-  }
-
-  async clear() {
-    this.#data.clear();
-  }
-}
-
-// ============================================================================
-// Adapter Registry Class
-// ============================================================================
-
-
-export class AdapterRegistry {
-  #storage;
-  #cache = new Map();
-  #cacheValid = false;
-
-  constructor(storage) {
-    // Use IndexedDB in browser, memory storage elsewhere
-    if (storage) {
-      this.#storage = storage;
-    } else if (typeof indexedDB !== 'undefined') {
-      this.#storage = new IndexedDBStorage();
-    } else if (isNodeRuntime()) {
-      this.#storage = new MemoryStorage();
-    } else {
-      throw new Error(
-        'AdapterRegistry requires IndexedDB in browser environments. ' +
-        'Pass explicit storage or use createMemoryRegistry() for tests.'
-      );
-    }
-  }
-
-  // ==========================================================================
-  // Registration
-  // ==========================================================================
-
-  
-  async register(manifest, location) {
-    // Validate manifest
-    const validation = validateManifest(manifest);
-    if (!validation.valid) {
-      const errors = validation.errors.map(e => `${e.field}: ${e.message}`).join('; ');
-      throw new Error(`Invalid manifest: ${errors}`);
-    }
-
-    const now = Date.now();
-
-    const entry = {
-      id: manifest.id,
-      name: manifest.name,
-      version: manifest.version || '1.0.0',
-      baseModel: manifest.baseModel,
-      rank: manifest.rank,
-      alpha: manifest.alpha,
-      targetModules: manifest.targetModules,
-      storageType: location.storageType,
-      manifestPath: location.manifestPath,
-      weightsPath: location.weightsPath,
-      weightsSize: manifest.weightsSize,
-      checksum: manifest.checksum,
-      metadata: manifest.metadata,
-      registeredAt: now,
-      lastAccessedAt: now,
-    };
-
-    await this.#storage.set(manifest.id, entry);
-    this.#cache.set(manifest.id, entry);
-
-    return entry;
-  }
-
-  
-  async registerFromUrl(url) {
-    const res = await fetch(url);
-    if (!res.ok) {
-      throw new Error(`Failed to fetch manifest: ${res.status} ${res.statusText}`);
-    }
-
-    const manifest = await res.json();
-
-    return this.register(manifest, {
-      storageType: 'url',
-      manifestPath: url,
-    });
-  }
-
-  // ==========================================================================
-  // Unregistration
-  // ==========================================================================
-
-  
-  async unregister(id) {
-    const deleted = await this.#storage.delete(id);
-    this.#cache.delete(id);
-    return deleted;
-  }
-
-  
-  async clear() {
-    await this.#storage.clear();
-    this.#cache.clear();
-    this.#cacheValid = false;
-  }
-
-  // ==========================================================================
-  // Query Methods
-  // ==========================================================================
-
-  
-  async get(id) {
-    // Check cache first
-    let entry = this.#cache.get(id);
-
-    if (!entry) {
-      entry = await this.#storage.get(id);
-      if (entry) {
-        this.#cache.set(id, entry);
-      }
-    }
-
-    if (entry) {
-      // Update last accessed time
-      entry.lastAccessedAt = Date.now();
-      await this.#storage.set(id, entry);
-    }
-
-    return entry || null;
-  }
-
-  
-  async list(options = {}) {
-    let entries = await this.#storage.getAll();
-
-    // Apply filters
-    if (options.baseModel) {
-      entries = entries.filter(e => e.baseModel === options.baseModel);
-    }
-
-    if (options.targetModules && options.targetModules.length > 0) {
-      entries = entries.filter(e =>
-        options.targetModules.every(mod => e.targetModules.includes(mod))
-      );
-    }
-
-    if (options.tags && options.tags.length > 0) {
-      entries = entries.filter(e =>
-        e.metadata?.tags?.some(tag => options.tags.includes(tag))
-      );
-    }
-
-    // Apply sorting
-    const sortField = options.sortBy || DEFAULT_ADAPTER_REGISTRY_CONFIG.defaultSortBy;
-    const sortOrder = options.sortOrder || DEFAULT_ADAPTER_REGISTRY_CONFIG.defaultSortOrder;
-    const sortMultiplier = sortOrder === 'asc' ? 1 : -1;
-
-    entries.sort((a, b) => {
-      const aVal = a[sortField];
-      const bVal = b[sortField];
-      if (typeof aVal === 'string' && typeof bVal === 'string') {
-        return sortMultiplier * aVal.localeCompare(bVal);
-      }
-      if (typeof aVal === 'number' && typeof bVal === 'number') {
-        return sortMultiplier * (aVal - bVal);
-      }
-      return 0;
-    });
-
-    // Apply pagination
-    if (options.offset) {
-      entries = entries.slice(options.offset);
-    }
-    if (options.limit) {
-      entries = entries.slice(0, options.limit);
-    }
-
-    return entries;
-  }
-
-  
-  async count(options = {}) {
-    const entries = await this.list(options);
-    return entries.length;
-  }
-
-  
-  async has(id) {
-    const entry = await this.#storage.get(id);
-    return entry !== null;
-  }
-
-  
-  async getBaseModels() {
-    const entries = await this.#storage.getAll();
-    const models = new Set(entries.map(e => e.baseModel));
-    return [...models].sort();
-  }
-
-  
-  async getTags() {
-    const entries = await this.#storage.getAll();
-    const tags = new Set();
-    for (const entry of entries) {
-      if (entry.metadata?.tags) {
-        for (const tag of entry.metadata.tags) {
-          tags.add(tag);
-        }
-      }
-    }
-    return [...tags].sort();
-  }
-
-  // ==========================================================================
-  // Update Methods
-  // ==========================================================================
-
-  
-  async updateMetadata(id, metadata) {
-    const entry = await this.#storage.get(id);
-    if (!entry) return null;
-
-    entry.metadata = {
-      ...entry.metadata,
-      ...metadata,
-      updatedAt: new Date().toISOString(),
-    };
-
-    await this.#storage.set(id, entry);
-    this.#cache.set(id, entry);
-
-    return entry;
-  }
-
-  
-  async updateLocation(id, location) {
-    const entry = await this.#storage.get(id);
-    if (!entry) return null;
-
-    if (location.storageType) entry.storageType = location.storageType;
-    if (location.manifestPath) entry.manifestPath = location.manifestPath;
-    if (location.weightsPath) entry.weightsPath = location.weightsPath;
-
-    await this.#storage.set(id, entry);
-    this.#cache.set(id, entry);
-
-    return entry;
-  }
-
-  // ==========================================================================
-  // Import/Export
-  // ==========================================================================
-
-  
-  async exportToJSON() {
-    const entries = await this.#storage.getAll();
-    return JSON.stringify(entries, null, 2);
-  }
-
-  
-  async importFromJSON(json, options = {}) {
-    let entries;
-    try {
-      entries = JSON.parse(json);
-    } catch (e) {
-      throw new Error(`Invalid JSON: ${e.message}`);
-    }
-
-    if (!Array.isArray(entries)) {
-      throw new Error('JSON must be an array of entries');
-    }
-
-    let imported = 0;
-    let skipped = 0;
-    const errors = [];
-
-    for (const entry of entries) {
-      try {
-        const existing = await this.#storage.get(entry.id);
-
-        if (existing && !options.overwrite) {
-          skipped++;
-          continue;
-        }
-
-        if (existing && options.merge) {
-          // Merge metadata
-          entry.metadata = { ...existing.metadata, ...entry.metadata };
-          entry.registeredAt = existing.registeredAt;
-        }
-
-        await this.#storage.set(entry.id, entry);
-        imported++;
-      } catch (e) {
-        errors.push(`${entry.id}: ${e.message}`);
-      }
-    }
-
-    // Invalidate cache
-    this.#cache.clear();
-    this.#cacheValid = false;
-
-    return { imported, skipped, errors };
-  }
-}
-
-// ============================================================================
-// Default Instance
-// ============================================================================
-
-
-let defaultRegistry = null;
-
-
-export function getAdapterRegistry() {
-  if (!defaultRegistry) {
-    defaultRegistry = new AdapterRegistry();
-  }
-  return defaultRegistry;
-}
-
-
-export function resetAdapterRegistry() {
-  defaultRegistry = null;
-}
-
-
-export function createMemoryRegistry() {
-  return new AdapterRegistry(new MemoryStorage());
-}