mycai 1.0.0

package/sdk/examples/express_integration.js

@@ -0,0 +1,61 @@
+/**
+ * Resonance SDK - Express.js Microservice Integration Example
+ * Embeds Resonance AI Engine into a secure B2B REST microservice.
+ * 
+ * Run with: node sdk/examples/express_integration.js
+ */
+
+import express from 'express';
+import { ResonanceEngine, LicenseManager } from '../index.js';
+
+const app = express();
+app.use(express.json());
+
+// Initialize Sovereign / Business Engine
+const licenseKey = process.env.RESONANCE_LICENSE_KEY || LicenseManager.generateLicenseKey({
+  tier: 'SOVEREIGN',
+  expiresAt: Date.now() + 365 * 24 * 3600 * 1000,
+  clientId: 'internal-enterprise'
+});
+
+const engine = new ResonanceEngine({ licenseKey });
+await engine.init();
+
+// 1. Q&A and Reasoning Endpoint (< 1ms)
+app.post('/api/ask', async (req, res) => {
+  try {
+    const { prompt } = req.body;
+    const result = await engine.ask(prompt);
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// 2. Document Ingestion Endpoint
+app.post('/api/ingest', async (req, res) => {
+  try {
+    const { data, type, title, metadata } = req.body;
+    const result = await engine.ingest({ data, type, title, metadata });
+    res.json(result);
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+// 3. Summarization Endpoint
+app.post('/api/summarize', (req, res) => {
+  const { page, document, mode } = req.body;
+  const summary = engine.summarize({ page, document, mode });
+  res.json({ summary });
+});
+
+// 4. Telemetry Endpoint
+app.get('/api/telemetry', (req, res) => {
+  res.json(engine.getTelemetry());
+});
+
+const PORT = process.env.PORT || 4100;
+app.listen(PORT, () => {
+  console.log(`📡 Resonance B2B Microservice active on http://localhost:${PORT}`);
+});

package/sdk/examples/node_example.js

@@ -0,0 +1,33 @@
+/**
+ * Resonance SDK v1.0 - Node.js Runtime Example
+ * Demonstrates basic text generation and morphology analysis in Node.js.
+ */
+
+import { ResonanceSDK } from '../resonance_sdk.js';
+
+async function run() {
+  console.log('--- Resonance SDK Node.js Example ---');
+  
+  const sdk = new ResonanceSDK({ temperature: 0.5, maxLength: 8 });
+  
+  console.log('Initializing SDK...');
+  await sdk.init();
+  console.log('SDK Metrics:', sdk.getMetrics());
+
+  // Generate text
+  console.log('\nGenerating text...');
+  const prompt = "yeni bir kitap";
+  const result = sdk.generate(prompt);
+  console.log(`Prompt: "${prompt}"`);
+  console.log(`Generated: "${result.generatedText}"`);
+  console.log(`Latency: ${result.totalLatencyMs.toFixed(2)} ms`);
+
+  // Analyze word
+  console.log('\nAnalyzing word morphology...');
+  const word = "evlerimizden";
+  const analysis = sdk.analyze(word);
+  console.log(`Word: "${word}"`);
+  console.log('Analysis:', analysis);
+}
+
+run().catch(console.error);

package/sdk/examples/quickstart.js

@@ -0,0 +1,55 @@
+/**
+ * Resonance SDK - 60 Second B2B Quickstart
+ * Run with: node sdk/examples/quickstart.js
+ */
+
+import { ResonanceEngine, LicenseManager, FileStorageAdapter } from '../index.js';
+
+async function main() {
+  console.log('🚀 Initializing Resonance Engine (B2B Infrastructure SDK)...');
+
+  // 1. Generate a test Business Tier License
+  const licenseKey = LicenseManager.generateLicenseKey({
+    tier: 'BUSINESS',
+    expiresAt: Date.now() + 30 * 24 * 3600 * 1000, // 30 days
+    clientId: 'acme-defense-corp'
+  });
+
+  // 2. Instantiate Engine with File Persistence
+  const engine = new ResonanceEngine({
+    licenseKey,
+    storage: new FileStorageAdapter('./scratch/quickstart_memory.json')
+  });
+
+  await engine.init();
+  console.log('✅ License Verified:', engine.getTelemetry().tier, '| Quota:', engine.getTelemetry().maxNodesQuota);
+
+  // 3. Ingest Law / Enterprise Knowledge
+  console.log('\n📥 Ingesting Document...');
+  await engine.ingest({
+    type: 'text',
+    title: '6100 Sayılı Hukuk Muhakemeleri Kanunu',
+    data: `
+Madde 1: Göreve ilişkin kurallar, kamu düzenindendir.
+Madde 2: Asliye hukuk mahkemelerinin görevi, dava konusunun değer ve miktarına bakılmaksızın, malvarlığı haklarına ilişkin davalarla şahıs varlığına ilişkin davaları görmektir.
+Madde 3: İflas ve konkordato davaları asliye ticaret mahkemesinde görülür.
+    `
+  });
+
+  // 4. Ask Direct Fact Question (< 1ms reaction)
+  console.log('\n❓ Query: "Asliye hukuk mahkemelerinin görevi nedir?"');
+  const response = await engine.ask("Asliye hukuk mahkemelerinin görevi nedir?");
+  console.log('⚡ Route:', response.route, '| Latency:', response.latencyMs, 'ms');
+  console.log('💬 Answer:\n', response.answer);
+
+  // 5. Ask Math AST Gate
+  console.log('\n❓ Math Gate Query: "250 * 4 + (1500 / 3)"');
+  const mathRes = await engine.ask("250 * 4 + (1500 / 3)");
+  console.log('⚡ Math Answer:', mathRes.answer, '| Latency:', mathRes.latencyMs, 'ms (Bypassed LLM:', mathRes.llmBypassed, ')');
+
+  // 6. Inspect Telemetry
+  console.log('\n📊 Real-Time Telemetry:');
+  console.log(engine.getTelemetry());
+}
+
+main().catch(console.error);

package/sdk/index.js

@@ -0,0 +1,22 @@
+/**
+ * @resonance/core — Commercial B2B Infrastructure SDK
+ * Zero-Cloud, Sub-Millisecond Turkish Language Intelligence & Sovereign Memory Engine.
+ * 
+ * @license Commercial
+ * @author Turkish Resonance AI Core Team
+ */
+
+export { ResonanceEngine, ResonanceSDK } from './resonance_engine.js';
+export { GHRLatticeMemory } from '../core/ghr_lattice_memory.js';
+export { LicenseManager, LICENSE_TIERS } from './licensing.js';
+export { IngestionEngine } from './ingestion.js';
+export {
+  BaseStorageAdapter,
+  MemoryStorageAdapter,
+  FileStorageAdapter,
+  IndexedDBStorageAdapter
+} from './storage.js';
+
+// Default export
+import { ResonanceEngine } from './resonance_engine.js';
+export default ResonanceEngine;

package/sdk/ingestion.js

@@ -0,0 +1,237 @@
+/**
+ * Resonance SDK - Modular Document Ingestion Engine
+ * Zero-Bloat Ingestion Pipeline: Text and CSV are native (0 KB external dependency).
+ * Heavy parsers (PDF, XLSX) are dynamically imported only on-demand when called.
+ * 
+ * @license Commercial
+ * @author Turkish Resonance AI Core Team
+ */
+
+export class IngestionEngine {
+  constructor(options = {}) {
+    this.maxChunkSize = options.maxChunkSize || 1000;
+    this.overlap = options.overlap || 100;
+    this._pdfModule = null;
+    this._xlsxModule = null;
+  }
+
+  /**
+   * Universal ingest method
+   * @param {Object} input
+   * @param {string|Buffer|ArrayBuffer} input.data - File content, text, or buffer
+   * @param {'text'|'pdf'|'csv'|'url'} [input.type='text']
+   * @param {string} [input.title='Untitled']
+   * @param {Object} [input.metadata={}]
+   * @returns {Promise<{ success: boolean, records: Array<{ query: string, content: string, confidence: number }>, stats: Object }>}
+   */
+  async ingest(input) {
+    if (!input || !input.data) {
+      throw new Error('Ingest input requires a valid "data" field');
+    }
+
+    const type = (input.type || this._detectType(input)).toLowerCase();
+    const title = input.title || 'Belge';
+    const metadata = input.metadata || {};
+
+    switch (type) {
+      case 'pdf':
+        return await this.ingestPdf(input.data, title, metadata);
+      case 'csv':
+      case 'tsv':
+        return this.ingestCsv(input.data, title, metadata);
+      case 'url':
+        return await this.ingestUrl(input.data, title, metadata);
+      case 'text':
+      default:
+        return this.ingestText(input.data, title, metadata);
+    }
+  }
+
+  /**
+   * Native lightweight plain text / markdown ingestion
+   */
+  ingestText(data, title, metadata = {}) {
+    const rawText = typeof data === 'string' ? data : data.toString('utf8');
+    
+    // Split by double newlines OR numbered articles like "Madde 1:", "1. ", etc.
+    let paragraphs = [];
+    if (/Madde\s+\d+[:.]/i.test(rawText)) {
+      paragraphs = rawText.split(/(?=\bMadde\s+\d+[:.])/i).map(p => p.trim()).filter(p => p.length > 10);
+    } else {
+      paragraphs = rawText
+        .split(/\n{2,}|\r\n\r\n/)
+        .map(p => p.trim())
+        .filter(p => p.length > 15);
+    }
+
+    const records = [];
+    if (paragraphs.length <= 1) {
+      const content = `${title} — ${rawText.trim()}`;
+      records.push({
+        query: `${title} ${rawText.slice(0, 300)}`,
+        content,
+        confidence: 0.90,
+        metadata: { ...metadata, section: 1 }
+      });
+    } else {
+      paragraphs.forEach((para, idx) => {
+        const content = `${title} — Bölüm ${idx + 1} — ${para}`;
+        records.push({
+          query: `${title} ${para.slice(0, 300)}`,
+          content,
+          confidence: 0.90,
+          metadata: { ...metadata, section: idx + 1 }
+        });
+      });
+    }
+
+    return {
+      success: true,
+      records,
+      stats: { type: 'text', totalRecords: records.length, characters: rawText.length }
+    };
+  }
+
+  /**
+   * Native lightweight CSV / TSV tabular ingestion (Zero-dependency)
+   */
+  ingestCsv(data, title, metadata = {}) {
+    const rawStr = typeof data === 'string' ? data : data.toString('utf8');
+    const lines = rawStr.split(/\r?\n/).map(l => l.trim()).filter(Boolean);
+    if (lines.length === 0) return { success: false, records: [], stats: { totalRecords: 0 } };
+
+    const delimiter = lines[0].includes('\t') ? '\t' : (lines[0].includes(';') ? ';' : ',');
+    const headers = lines[0].split(delimiter).map(h => h.trim().replace(/^["']|["']$/g, '').toLowerCase());
+
+    // Map common Turkish / English columns
+    const titleIdx = headers.findIndex(h => /başlık|baslik|title|name|ad|proje|konu/i.test(h));
+    const descIdx = headers.findIndex(h => /açıklama|aciklama|desc|özet|ozet|detay|summary|detail/i.test(h));
+
+    const records = [];
+    for (let i = 1; i < lines.length; i++) {
+      const parts = lines[i].split(delimiter).map(p => p.trim().replace(/^["']|["']$/g, ''));
+      if (parts.length < 2) continue;
+
+      const itemTitle = titleIdx >= 0 && parts[titleIdx] ? parts[titleIdx] : `${title} #${i}`;
+      let itemDesc = '';
+
+      if (descIdx >= 0 && parts[descIdx]) {
+        itemDesc = parts[descIdx];
+      } else {
+        itemDesc = headers.map((h, hIdx) => `${h}: ${parts[hIdx] || ''}`).join(', ');
+      }
+
+      const content = `${itemTitle} — ${itemDesc}`;
+      records.push({
+        query: `${title} ${itemTitle} ${itemDesc}`,
+        content,
+        confidence: 0.88,
+        metadata: { ...metadata, row: i }
+      });
+    }
+
+    return {
+      success: true,
+      records,
+      stats: { type: 'csv', totalRecords: records.length, rows: lines.length - 1 }
+    };
+  }
+
+  /**
+   * On-Demand Dynamic PDF Ingestion (Keeps core SDK ultra-lightweight)
+   */
+  async ingestPdf(data, title, metadata = {}) {
+    let pdfjs = null;
+
+    // 1. Check browser global
+    if (typeof window !== 'undefined' && window.pdfjsLib) {
+      pdfjs = window.pdfjsLib;
+    } else {
+      // 2. Dynamic import in Node.js
+      try {
+        pdfjs = await import('pdfjs-dist/legacy/build/pdf.js');
+      } catch (e) {
+        throw new Error('PDF parsing requires "pdfjs-dist" package in Node.js or "pdf.min.js" in Browser. Install via: npm install pdfjs-dist');
+      }
+    }
+
+    let rawBuffer = data;
+    if (typeof data === 'string') {
+      // Handle base64 string
+      const binaryStr = atob(data);
+      const bytes = new Uint8Array(binaryStr.length);
+      for (let i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i);
+      rawBuffer = bytes;
+    } else if (Buffer.isBuffer(data)) {
+      rawBuffer = new Uint8Array(data);
+    }
+
+    const doc = await pdfjs.getDocument({ data: rawBuffer }).promise;
+    const records = [];
+    const maxPages = Math.min(doc.numPages, 100);
+
+    for (let p = 1; p <= maxPages; p++) {
+      const page = await doc.getPage(p);
+      const textContent = await page.getTextContent();
+      const pageText = textContent.items.map(it => it.str).join(' ').trim();
+      if (pageText.length > 20) {
+        const content = `${title} — Sayfa ${p} — ${pageText}`;
+        records.push({
+          query: `${title} sayfa ${p} ${pageText.slice(0, 300)}`,
+          content,
+          confidence: 0.92,
+          metadata: { ...metadata, page: p, totalPages: doc.numPages }
+        });
+      }
+    }
+
+    return {
+      success: true,
+      records,
+      stats: { type: 'pdf', totalPages: doc.numPages, processedPages: records.length }
+    };
+  }
+
+  /**
+   * URL Ingestion (HTML clean text extraction)
+   */
+  async ingestUrl(url, title, metadata = {}) {
+    if (typeof fetch === 'undefined') {
+      throw new Error('URL ingestion requires global fetch API');
+    }
+
+    const resp = await fetch(url);
+    if (!resp.ok) throw new Error(`Failed to fetch URL: HTTP ${resp.status}`);
+
+    const contentType = resp.headers.get('content-type') || '';
+    if (contentType.includes('pdf') || url.endsWith('.pdf')) {
+      const arrayBuf = await resp.arrayBuffer();
+      return await this.ingestPdf(new Uint8Array(arrayBuf), title, metadata);
+    }
+
+    const rawHtml = await resp.text();
+    const cleanText = rawHtml
+      .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, ' ')
+      .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, ' ')
+      .replace(/<[^>]+>/g, ' ')
+      .replace(/&nbsp;/g, ' ')
+      .replace(/\s{2,}/g, ' ')
+      .trim();
+
+    return this.ingestText(cleanText, title, { ...metadata, sourceUrl: url });
+  }
+
+  _detectType(input) {
+    if (typeof input.data === 'string') {
+      if (input.data.startsWith('http://') || input.data.startsWith('https://')) return 'url';
+      if (input.data.includes(',') && input.data.includes('\n')) return 'csv';
+      return 'text';
+    }
+    if (input.filename) {
+      const ext = input.filename.split('.').pop().toLowerCase();
+      if (ext === 'pdf') return 'pdf';
+      if (ext === 'csv') return 'csv';
+    }
+    return 'text';
+  }
+}

package/sdk/licensing.js

@@ -0,0 +1,168 @@
+/**
+ * Resonance SDK - Commercial Offline Licensing Engine (B2B Infrastructure)
+ * 100% Air-Gapped cryptographic license validation and quota enforcement.
+ * 
+ * License format: RES-{TIER}-{EXPIRY_TIMESTAMP}-{MAX_NODES}-{HMAC_SIGNATURE}
+ * Example: RES-BUSINESS-1798761600000-50000-a1b2c3d4e5f6...
+ * 
+ * @license Commercial
+ * @author Turkish Resonance AI Core Team
+ */
+
+import crypto from 'crypto';
+
+export const LICENSE_TIERS = {
+  STARTER: {
+    name: 'Starter',
+    maxNodes: 1000,
+    allowedRuntimes: ['node', 'browser'],
+    features: ['math', 'text', 'basic_memory', 'telemetry'],
+    wasmRequired: false
+  },
+  BUSINESS: {
+    name: 'Business',
+    maxNodes: 50000,
+    allowedRuntimes: ['node', 'browser', 'electron', 'edge'],
+    features: ['math', 'morphology', 'text', 'basic_memory', 'pdf', 'csv', 'living_memory', 'smart_summarizer', 'conflict_resolution', 'telemetry'],
+    wasmRequired: false
+  },
+  SOVEREIGN: {
+    name: 'Sovereign',
+    maxNodes: Infinity,
+    allowedRuntimes: ['node', 'browser', 'electron', 'edge', 'tactical_hardware'],
+    features: ['math', 'morphology', 'text', 'basic_memory', 'pdf', 'csv', 'living_memory', 'smart_summarizer', 'conflict_resolution', 'wasm_simd', 'custom_rules', 'multi_graph', 'telemetry'],
+    wasmRequired: true
+  }
+};
+
+export class LicenseManager {
+  /**
+   * @param {string} [vendorSecret] - Master secret for signing/verifying licenses.
+   */
+  constructor(vendorSecret = 'RESONANCE_SOVEREIGN_KEY_2026_AIRGAPPED_HMAC') {
+    this._secret = vendorSecret;
+    this.currentLicense = null;
+    this.tier = LICENSE_TIERS.STARTER;
+    this.expiryDate = null;
+    this.maxNodes = 1000;
+    this.isValid = false;
+    this.nodeCount = 0;
+  }
+
+  /**
+   * Generate an offline commercial license key (Vendor use)
+   * @param {Object} opts
+   * @param {'STARTER'|'BUSINESS'|'SOVEREIGN'} opts.tier
+   * @param {number|Date} opts.expiresAt
+   * @param {number} [opts.maxNodes]
+   * @param {string} [opts.clientId]
+   * @returns {string}
+   */
+  static generateLicenseKey(opts, secret = 'RESONANCE_SOVEREIGN_KEY_2026_AIRGAPPED_HMAC') {
+    const tierKey = (opts.tier || 'STARTER').toUpperCase();
+    if (!LICENSE_TIERS[tierKey]) throw new Error(`Invalid tier: ${tierKey}`);
+
+    const tierDef = LICENSE_TIERS[tierKey];
+    const expiry = opts.expiresAt instanceof Date ? opts.expiresAt.getTime() : (opts.expiresAt || (Date.now() + 365 * 24 * 3600 * 1000));
+    const maxNodes = opts.maxNodes || (tierDef.maxNodes === Infinity ? 0 : tierDef.maxNodes);
+    const clientId = (opts.clientId || 'b2b-customer').replace(/[^a-zA-Z0-9]/g, '');
+
+    const payload = `${tierKey}:${expiry}:${maxNodes}:${clientId}`;
+    const hmac = crypto.createHmac('sha256', secret);
+    hmac.update(payload);
+    const signature = hmac.digest('hex').slice(0, 32);
+
+    return `RES-${tierKey}-${expiry}-${maxNodes}-${clientId}-${signature}`;
+  }
+
+  /**
+   * Cryptographically verify an offline license key without cloud ping
+   * @param {string} key
+   * @returns {{ valid: boolean, tier: Object, expiresAt: Date, maxNodes: number, reason?: string }}
+   */
+  verifyLicense(key) {
+    if (!key || typeof key !== 'string') {
+      return this._fallbackCommunityLicense('No license key provided');
+    }
+
+    const parts = key.trim().split('-');
+    if (parts.length !== 6 || parts[0] !== 'RES') {
+      return this._fallbackCommunityLicense('Invalid license key format');
+    }
+
+    const [_, tierKey, expiryStr, maxNodesStr, clientId, signature] = parts;
+    const tierDef = LICENSE_TIERS[tierKey];
+    if (!tierDef) {
+      return this._fallbackCommunityLicense(`Unrecognized tier: ${tierKey}`);
+    }
+
+    const expiryTime = parseInt(expiryStr, 10);
+    const maxNodes = parseInt(maxNodesStr, 10);
+
+    // Verify cryptographic signature
+    const payload = `${tierKey}:${expiryTime}:${maxNodes}:${clientId}`;
+    const hmac = crypto.createHmac('sha256', this._secret);
+    hmac.update(payload);
+    const expectedSig = hmac.digest('hex').slice(0, 32);
+
+    // Constant-time comparison
+    if (!crypto.timingSafeEqual(Buffer.from(signature, 'hex'), Buffer.from(expectedSig, 'hex'))) {
+      return this._fallbackCommunityLicense('Cryptographic signature verification failed');
+    }
+
+    // Check expiration
+    if (Date.now() > expiryTime) {
+      return this._fallbackCommunityLicense(`License expired on ${new Date(expiryTime).toISOString()}`);
+    }
+
+    // Valid license
+    this.currentLicense = key;
+    this.tier = tierDef;
+    this.expiryDate = new Date(expiryTime);
+    this.maxNodes = maxNodes === 0 ? Infinity : maxNodes;
+    this.isValid = true;
+
+    return {
+      valid: true,
+      tier: tierDef,
+      expiresAt: this.expiryDate,
+      maxNodes: this.maxNodes,
+      clientId
+    };
+  }
+
+  /**
+   * Check if a feature is authorized by the current license
+   * @param {string} featureName
+   * @returns {boolean}
+   */
+  canUseFeature(featureName) {
+    return this.tier.features.includes(featureName);
+  }
+
+  /**
+   * Check if adding N nodes exceeds quota
+   * @param {number} currentTotal
+   * @param {number} addingCount
+   * @returns {boolean}
+   */
+  checkNodeQuota(currentTotal, addingCount = 1) {
+    if (this.maxNodes === Infinity) return true;
+    return (currentTotal + addingCount) <= this.maxNodes;
+  }
+
+  _fallbackCommunityLicense(reason) {
+    this.currentLicense = null;
+    this.tier = LICENSE_TIERS.STARTER;
+    this.expiryDate = null;
+    this.maxNodes = LICENSE_TIERS.STARTER.maxNodes;
+    this.isValid = false;
+    return {
+      valid: false,
+      tier: this.tier,
+      expiresAt: null,
+      maxNodes: this.maxNodes,
+      reason
+    };
+  }
+}