mycai 1.0.0

package/sdk/storage.js

@@ -0,0 +1,185 @@
+/**
+ * Resonance SDK - Storage Adapter Interface & Implementations
+ * Pluggable persistence layer for living memory nodes and telemetry across runtimes.
+ * 
+ * @license Commercial
+ * @author Turkish Resonance AI Core Team
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Base abstract storage adapter
+ */
+export class BaseStorageAdapter {
+  constructor(name = 'default') {
+    this.name = name;
+  }
+  async init() {}
+  async load() { return []; }
+  async save(records) { return true; }
+  async clear() { return true; }
+}
+
+/**
+ * In-Memory RAM Storage Adapter (Ultra-fast, zero disk dependency, default)
+ */
+export class MemoryStorageAdapter extends BaseStorageAdapter {
+  constructor() {
+    super('memory');
+    this._records = [];
+  }
+
+  async load() {
+    return [...this._records];
+  }
+
+  async save(records) {
+    this._records = Array.isArray(records) ? [...records] : [];
+    return true;
+  }
+
+  async clear() {
+    this._records = [];
+    return true;
+  }
+}
+
+/**
+ * Node.js Local File Storage Adapter (Persists memory snapshots to disk)
+ */
+export class FileStorageAdapter extends BaseStorageAdapter {
+  /**
+   * @param {string} filePath - Path to JSON persistence file
+   */
+  constructor(filePath = './resonance_memory.json') {
+    super('file');
+    this.filePath = path.resolve(filePath);
+  }
+
+  async init() {
+    const dir = path.dirname(this.filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  async load() {
+    try {
+      if (!fs.existsSync(this.filePath)) return [];
+      const content = fs.readFileSync(this.filePath, 'utf8');
+      const data = JSON.parse(content);
+      return Array.isArray(data) ? data : [];
+    } catch (e) {
+      console.warn(`[Resonance Storage] Failed to load from ${this.filePath}:`, e.message);
+      return [];
+    }
+  }
+
+  async save(records) {
+    try {
+      await this.init();
+      fs.writeFileSync(this.filePath, JSON.stringify(records, null, 2), 'utf8');
+      return true;
+    } catch (e) {
+      console.error(`[Resonance Storage] Failed to save to ${this.filePath}:`, e.message);
+      return false;
+    }
+  }
+
+  async clear() {
+    try {
+      if (fs.existsSync(this.filePath)) {
+        fs.unlinkSync(this.filePath);
+      }
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+}
+
+/**
+ * Browser / Electron IndexedDB Storage Adapter
+ */
+export class IndexedDBStorageAdapter extends BaseStorageAdapter {
+  constructor(dbName = 'ResonanceMemoryDB', storeName = 'nodes') {
+    super('indexeddb');
+    this.dbName = dbName;
+    this.storeName = storeName;
+    this._db = null;
+  }
+
+  async init() {
+    if (typeof indexedDB === 'undefined') {
+      return; // Fallback to memory if indexedDB not in environment
+    }
+    return new Promise((resolve, reject) => {
+      const req = indexedDB.open(this.dbName, 1);
+      req.onupgradeneeded = (e) => {
+        const db = e.target.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName, { keyPath: 'id', autoIncrement: true });
+        }
+      };
+      req.onsuccess = () => {
+        this._db = req.result;
+        resolve();
+      };
+      req.onerror = () => reject(req.error);
+    });
+  }
+
+  async load() {
+    if (!this._db) await this.init();
+    if (!this._db) return [];
+
+    return new Promise((resolve) => {
+      try {
+        const tx = this._db.transaction(this.storeName, 'readonly');
+        const store = tx.objectStore(this.storeName);
+        const req = store.getAll();
+        req.onsuccess = () => resolve(req.result || []);
+        req.onerror = () => resolve([]);
+      } catch (e) {
+        resolve([]);
+      }
+    });
+  }
+
+  async save(records) {
+    if (!this._db) await this.init();
+    if (!this._db) return false;
+
+    return new Promise((resolve) => {
+      try {
+        const tx = this._db.transaction(this.storeName, 'readwrite');
+        const store = tx.objectStore(this.storeName);
+        store.clear();
+        (records || []).forEach(r => store.add(r));
+        tx.oncomplete = () => resolve(true);
+        tx.onerror = () => resolve(false);
+      } catch (e) {
+        resolve(false);
+      }
+    });
+  }
+
+  async clear() {
+    if (!this._db) await this.init();
+    if (!this._db) return true;
+
+    return new Promise((resolve) => {
+      try {
+        const tx = this._db.transaction(this.storeName, 'readwrite');
+        const store = tx.objectStore(this.storeName);
+        store.clear();
+        tx.oncomplete = () => resolve(true);
+        tx.onerror = () => resolve(false);
+      } catch (e) {
+        resolve(false);
+      }
+    });
+  }
+}

package/sdk/tests/sdk_verification.js

@@ -0,0 +1,98 @@
+/**
+ * Resonance SDK v1.0 - SDK Verification Suite
+ * Asserts: zero-copy WASM interface, memory limits, OOV correctness, and generation consistency.
+ */
+
+import { ResonanceSDK } from '../resonance_sdk.js';
+
+let passed = 0, failed = 0, total = 0;
+
+function assert(name, condition, detail = '') {
+  total++;
+  if (condition) {
+    passed++;
+    console.log(`  ✅ ${name}`);
+  } else {
+    failed++;
+    console.log(`  ❌ ${name} ${detail}`);
+  }
+}
+
+async function runTests() {
+  console.log('\n╔══════════════════════════════════════════════════════════╗');
+  console.log('║         RESONANCE SDK v1.0 — SPEC VERIFICATION           ║');
+  console.log('╚══════════════════════════════════════════════════════════╝\n');
+
+  // 1. Initialize SDK
+  console.log('▸ 1. Initialization and Runtime Verification');
+  const sdk = new ResonanceSDK({ D: 4096 });
+  await sdk.init();
+  assert('SDK initialized successfully', sdk._initialized);
+  assert('WASM instance is active', sdk.wasmInstance !== null);
+  assert('WASM memory is active', sdk.wasmMemory !== null);
+
+  // 2. Zero-Copy Interface Checks
+  console.log('\n▸ 2. Zero-Copy Memory Assertions');
+  // Check pointers are non-zero and allocated within WASM linear memory
+  assert('vocabCosPtr is allocated', sdk.vocabCosPtr > 0);
+  assert('vocabSinPtr is allocated', sdk.vocabSinPtr > 0);
+  assert('scoresPtr is allocated', sdk.scoresPtr > 0);
+  assert('candidateIndicesPtr is allocated', sdk.candidateIndicesPtr > 0);
+
+  // Validate shared memory buffers (float arrays point to the exact same buffer)
+  const memBuffer = sdk.wasmMemory.buffer;
+  assert('WASM memory is an ArrayBuffer', memBuffer instanceof ArrayBuffer);
+  
+  // Try writing a small test slice to candidates ptr and checking it matches WASM buffer
+  const testPool = [1, 5, 10, 42];
+  const candView = new Int32Array(memBuffer, sdk.candidateIndicesPtr, testPool.length);
+  candView.set(testPool);
+  
+  // Check that writing directly updates memory
+  const checkCandView = new Int32Array(memBuffer, sdk.candidateIndicesPtr, testPool.length);
+  assert('Zero-copy candidate pointer is writable and readable', 
+    checkCandView[0] === 1 && checkCandView[3] === 42
+  );
+
+  // 3. Memory Footprint / Limits Check
+  console.log('\n▸ 3. Memory Footprint Limits Assertions');
+  const heapBytes = sdk.wasmMemory.buffer.byteLength;
+  const heapMb = heapBytes / (1024 * 1024);
+  console.log(`   → WASM Linear Memory Allocated: ${heapMb.toFixed(2)} MB`);
+  // Assert memory stays well below commercial target limit for large vocabulary (e.g., 1500 MB)
+  assert('WASM memory usage is within commercial limits (< 1500 MB)', heapMb < 1500);
+
+  // 4. OOV Correctness Checks
+  console.log('\n▸ 4. Out-of-Vocabulary (OOV) Safety Assertions');
+  // Verify <unk> exists in vocab
+  assert('<unk> token is at index 0', sdk.vocab[0] === '<unk>');
+  assert('<unk> index lookup works', sdk.vocabMap.get('<unk>') === 0);
+
+  // Run generation with completely unknown words (OOV)
+  const oovPrompt = "xyzabc123 qwerty999";
+  const result = sdk.generate(oovPrompt, { maxLength: 3 });
+  assert('OOV prompt generation completed without crashing', result !== null);
+  assert('OOV prompt generated valid output words', result.newTokens.length > 0);
+  console.log(`   → OOV Prompt: "${oovPrompt}"`);
+  console.log(`   → Assistant Output: "${result.generatedText}"`);
+
+  // 5. Morphological Expansion Verification
+  console.log('\n▸ 5. Turkish Morphological Expansion Verification');
+  const testWord = "kitaplarımızdan";
+  const analysis = sdk.analyze(testWord);
+  assert('Morphology analysis returns valid object', typeof analysis === 'object');
+  assert('Correct root detected', analysis.root === 'kitap');
+  assert('Suffixes array populated', analysis.suffixes.includes('lar') && analysis.suffixes.includes('dan'));
+
+  // ── SUMMARY ───────────────────────────────────────────
+  console.log('\n╔══════════════════════════════════════════════════════════╗');
+  console.log(`║  RESULTS: ${passed}/${total} PASSED  ${failed > 0 ? `(${failed} FAILED)` : '✨ ALL CLEAR'}  ║`);
+  console.log('╚══════════════════════════════════════════════════════════╝\n');
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+runTests().catch(e => {
+  console.error('Test runner failure:', e);
+  process.exit(1);
+});

package/sdk/tests/test_commercial_sdk.js

@@ -0,0 +1,136 @@
+/**
+ * Automated Test Suite for @resonance/core Commercial SDK
+ * Run with: node sdk/tests/test_commercial_sdk.js
+ */
+
+import assert from 'assert';
+import fs from 'fs';
+import {
+  ResonanceEngine,
+  LicenseManager,
+  LICENSE_TIERS,
+  MemoryStorageAdapter,
+  FileStorageAdapter
+} from '../index.js';
+
+async function runTests() {
+  console.log('🧪 Starting Commercial B2B SDK Automated Verification...\n');
+
+  // ── 1. Cryptographic Offline Licensing Tests ─────────────────
+  console.log('Test 1: Cryptographic Offline Licensing...');
+  const secret = 'TEST_VENDOR_SECRET_KEY_12345';
+  const validKey = LicenseManager.generateLicenseKey({
+    tier: 'BUSINESS',
+    expiresAt: Date.now() + 100000,
+    clientId: 'test-bank'
+  }, secret);
+
+  const licMgr = new LicenseManager(secret);
+  const verifyRes = licMgr.verifyLicense(validKey);
+  assert.strictEqual(verifyRes.valid, true, 'License should be cryptographically valid');
+  assert.strictEqual(verifyRes.tier.name, 'Business', 'Tier should be Business');
+  assert.strictEqual(verifyRes.maxNodes, 50000, 'Max nodes should be 50,000');
+
+  // Test Tampered License
+  const tamperedKey = validKey.slice(0, -4) + 'ffff';
+  const tamperedRes = licMgr.verifyLicense(tamperedKey);
+  assert.strictEqual(tamperedRes.valid, false, 'Tampered license signature must fail');
+
+  // Test Expired License
+  const expiredKey = LicenseManager.generateLicenseKey({
+    tier: 'STARTER',
+    expiresAt: Date.now() - 1000,
+    clientId: 'test-expired'
+  }, secret);
+  const expiredRes = licMgr.verifyLicense(expiredKey);
+  assert.strictEqual(expiredRes.valid, false, 'Expired license must fail');
+  console.log('✅ License verification and tamper resistance passed.');
+
+  // ── 2. Storage Adapter Persistence Tests ─────────────────────
+  console.log('\nTest 2: Storage Adapters (Memory & File)...');
+  const tempPath = './scratch/test_memory_storage.json';
+  const fileStorage = new FileStorageAdapter(tempPath);
+  await fileStorage.init();
+  await fileStorage.save([{ id: 1, content: 'Test Memory' }]);
+  const loaded = await fileStorage.load();
+  assert.strictEqual(loaded.length, 1, 'File storage should persist and reload records');
+  assert.strictEqual(loaded[0].content, 'Test Memory');
+  await fileStorage.clear();
+  assert.strictEqual((await fileStorage.load()).length, 0, 'Clear should empty file storage');
+  if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+  console.log('✅ Storage adapters passed.');
+
+  // ── 3. Engine Initialization & Ingestion Tests ───────────────
+  console.log('\nTest 3: Engine Ingestion (Text & CSV)...');
+  const engine = new ResonanceEngine({
+    licenseKey: validKey,
+    vendorSecret: secret,
+    storage: new MemoryStorageAdapter()
+  });
+  await engine.init();
+
+  // Ingest Text
+  const textIngest = await engine.ingest({
+    type: 'text',
+    title: 'Ticaret Kanunu',
+    data: `
+Madde 1: Türk Ticaret Kanunu, 6102 sayılı kanundur.
+Madde 2: Tacir, bir ticari işletmeyi kısmen de olsa kendi adına işleten kişidir.
+Madde 3: Ticaret şirketleri; kollektif, komandit, anonim, limited ve kooperatif şirketlerden ibarettir.
+    `
+  });
+  assert.strictEqual(textIngest.success, true);
+  assert.strictEqual(textIngest.recordsAdded, 3);
+
+  // Ingest CSV
+  const csvIngest = await engine.ingest({
+    type: 'csv',
+    title: 'Şirket Verileri',
+    data: `
+Proje,Açıklama,Durum
+Resonance AI,Yerel Türkçe Bilişsel Çekirdek,Aktif
+Opacus,Otonom Ajan Güvenlik Katmanı,Aktif
+    `
+  });
+  assert.strictEqual(csvIngest.success, true);
+  assert.strictEqual(csvIngest.recordsAdded, 2);
+  console.log('✅ Document and tabular ingestion passed.');
+
+  // ── 4. Precision Q&A and Routing Tests ───────────────────────
+  console.log('\nTest 4: Precision Q&A Dispatcher...');
+
+  // Direct fact question
+  const q1 = await engine.ask('Tacir kimdir?');
+  console.log('Q1 Answer:', q1.answer);
+  assert.strictEqual(q1.route, 'memory_qa_detail');
+  assert.ok(q1.answer.includes('kendi adına işleten'), 'Should extract definition of tacir');
+  assert.ok(q1.latencyMs < 50, 'Latency must be sub-50ms in testing');
+
+  // Math Gate
+  const q2 = await engine.ask('150 * 3 + 50');
+  console.log('Q2 Math:', q2.answer);
+  assert.strictEqual(q2.route, 'math');
+  assert.strictEqual(q2.answer, '500');
+
+  // Morphology Gate
+  const q3 = await engine.ask('bilgisayarlarımızdan');
+  console.log('Q3 Morphology:', q3.answer);
+  assert.strictEqual(q3.route, 'morphology');
+  assert.ok(q3.answer.includes('bilgisayar'));
+
+  // ── 5. Telemetry & Quota Enforcement ─────────────────────────
+  console.log('\nTest 5: Telemetry and Quota...');
+  const telemetry = engine.getTelemetry();
+  console.log('Telemetry Output:', telemetry);
+  assert.strictEqual(telemetry.tier, 'Business');
+  assert.strictEqual(telemetry.licenseValid, true);
+  assert.ok(telemetry.totalQueries >= 3);
+  assert.strictEqual(telemetry.activeNodes, 5);
+
+  console.log('\n🎉 ALL COMMERCIAL SDK TESTS PASSED SUCCESSFULLY!');
+}
+
+runTests().catch(err => {
+  console.error('\n❌ TEST FAILED:', err);
+  process.exit(1);
+});

package/sdk/types.d.ts

@@ -0,0 +1,152 @@
+/**
+ * TypeScript Definitions for @resonance/core (Commercial B2B SDK)
+ */
+
+export interface LicenseTier {
+  name: 'Starter' | 'Business' | 'Sovereign';
+  maxNodes: number;
+  allowedRuntimes: string[];
+  features: string[];
+  wasmRequired: boolean;
+}
+
+export interface LicenseVerificationResult {
+  valid: boolean;
+  tier: LicenseTier;
+  expiresAt: Date | null;
+  maxNodes: number;
+  clientId?: string;
+  reason?: string;
+}
+
+export interface IngestInput {
+  data: string | Buffer | ArrayBuffer;
+  type?: 'text' | 'pdf' | 'csv' | 'tsv' | 'url';
+  title?: string;
+  metadata?: Record<string, any>;
+}
+
+export interface IngestRecord {
+  query: string;
+  content: string;
+  confidence: number;
+  metadata?: Record<string, any>;
+}
+
+export interface IngestResult {
+  success: boolean;
+  recordsAdded: number;
+  totalMemoryNodes?: number;
+  stats?: Record<string, any>;
+}
+
+export interface AskResult {
+  answer: string;
+  route: string;
+  confidence: number;
+  latencyMs: number;
+  llmBypassed: boolean;
+  tier: string;
+  metadata?: Record<string, any>;
+}
+
+export interface SummarizeOptions {
+  page?: number;
+  document?: string;
+  mode?: 'concise' | 'single' | 'full';
+}
+
+export interface SearchResult {
+  content: string;
+  score: number;
+  metadata?: Record<string, any>;
+}
+
+export interface TelemetryMetrics {
+  activeNodes: number;
+  maxNodesQuota: number;
+  tier: string;
+  licenseValid: boolean;
+  totalQueries: number;
+  avgLatencyMs: number;
+  bypassedLlmCount: number;
+  storageType: string;
+  uptimeSeconds: number;
+}
+
+export interface ResonanceConfig {
+  licenseKey?: string;
+  D?: number;
+  storage?: BaseStorageAdapter;
+  vendorSecret?: string;
+  ingestion?: {
+    maxChunkSize?: number;
+    overlap?: number;
+  };
+}
+
+export declare class BaseStorageAdapter {
+  name: string;
+  init(): Promise<void>;
+  load(): Promise<any[]>;
+  save(records: any[]): Promise<boolean>;
+  clear(): Promise<boolean>;
+}
+
+export declare class MemoryStorageAdapter extends BaseStorageAdapter {}
+export declare class FileStorageAdapter extends BaseStorageAdapter {
+  constructor(filePath?: string);
+}
+export declare class IndexedDBStorageAdapter extends BaseStorageAdapter {
+  constructor(dbName?: string, storeName?: string);
+}
+
+export declare class LicenseManager {
+  constructor(vendorSecret?: string);
+  static generateLicenseKey(opts: {
+    tier: 'STARTER' | 'BUSINESS' | 'SOVEREIGN';
+    expiresAt: number | Date;
+    maxNodes?: number;
+    clientId?: string;
+  }, secret?: string): string;
+  verifyLicense(key: string): LicenseVerificationResult;
+  canUseFeature(featureName: string): boolean;
+  checkNodeQuota(currentTotal: number, addingCount?: number): boolean;
+}
+
+export declare class IngestionEngine {
+  constructor(options?: { maxChunkSize?: number; overlap?: number });
+  ingest(input: IngestInput): Promise<{
+    success: boolean;
+    records: IngestRecord[];
+    stats: Record<string, any>;
+  }>;
+}
+
+export declare class GHRLatticeMemory {
+  D: number;
+  cellSize: number;
+  sigma: number;
+  cells: any[];
+  constructor(config?: { D?: number; cellSize?: number; sigma?: number; seed?: number; numTables?: number; numProjections?: number });
+  encodePacket(phases: Float64Array, channelIndex: number): { real: Float64Array; imag: Float64Array; channel: number };
+  insert(factVector: { id: string; phases: Float64Array }, metadata?: Record<string, any>): any;
+  query(queryVector: { id?: string; phases: Float64Array }, topK?: number): Array<{ item: any; score: number; rank: number; latencyMs: number }>;
+  calculateSIR(queryVector: { id?: string; phases: Float64Array }, targetId: string): number;
+  readonly stats: { D: number; totalCells: number; totalItems: number; cellSizeLimit: number; sigma: number };
+}
+
+export declare class ResonanceEngine {
+  constructor(config?: ResonanceConfig);
+  init(): Promise<this>;
+  ask(prompt: string, options?: Record<string, any>): Promise<AskResult>;
+  ingest(input: IngestInput): Promise<IngestResult>;
+  summarize(opts?: SummarizeOptions): string;
+  search(query: string, limit?: number): SearchResult[];
+  clearMemory(): Promise<boolean>;
+  onConflict(handler: (existing: any, incoming: any) => void): void;
+  getTelemetry(): TelemetryMetrics;
+}
+
+export { ResonanceEngine as ResonanceSDK };
+export default ResonanceEngine;