mycai 1.0.0

package/core/resonance.js

@@ -0,0 +1,118 @@
+/**
+ * Resonance Engine Module
+ * Computes multi-dimensional resonance metrics combining Semantic, Morphology, Spectral, Phase, and Context.
+ */
+
+import { TurkishMorphology } from './morphology.js';
+import { HDCEngine } from './hdc.js';
+import { SpectralEngine } from './spectral.js';
+import { PhaseEngine } from './phase.js';
+
+export class ResonanceEngine {
+  constructor(config = {}) {
+    // Configurable weights (default values as requested)
+    this.alpha = config.alpha !== undefined ? config.alpha : 0.30; // Semantic
+    this.beta = config.beta !== undefined ? config.beta : 0.20;   // Morphology
+    this.gamma = config.gamma !== undefined ? config.gamma : 0.20; // Spectral
+    this.delta = config.delta !== undefined ? config.delta : 0.20; // Phase
+    this.epsilon = config.epsilon !== undefined ? config.epsilon : 0.10; // Context
+
+    this.morphology = new TurkishMorphology();
+    this.hdc = new HDCEngine();
+    this.spectral = new SpectralEngine();
+    this.phase = new PhaseEngine();
+  }
+
+  updateWeights(config) {
+    if (config.alpha !== undefined) this.alpha = config.alpha;
+    if (config.beta !== undefined) this.beta = config.beta;
+    if (config.gamma !== undefined) this.gamma = config.gamma;
+    if (config.delta !== undefined) this.delta = config.delta;
+    if (config.epsilon !== undefined) this.epsilon = config.epsilon;
+  }
+
+  computeResonance(query, candidate, queryRepr, candidateRepr) {
+    // 1. Semantic Score (cosine similarity in HDC domain)
+    const semanticScore = this.hdc.similarity(queryRepr, candidateRepr);
+
+    // 2. Morphology Score (root matches + suffix overlaps)
+    const morphQ = this.morphology.analyze(query);
+    const morphC = this.morphology.analyze(candidate);
+    let morphologyScore = 0.0;
+
+    if (morphQ.root === morphC.root) {
+      morphologyScore += 0.6; // heavy weighting for sharing the same root
+    }
+    // Calculate overlap of suffixes
+    const setQ = new Set(morphQ.suffixes);
+    const setC = new Set(morphC.suffixes);
+    let intersections = 0;
+    setQ.forEach(s => {
+      if (setC.has(s)) intersections++;
+    });
+    const unionSize = new Set([...setQ, ...setC]).size;
+    if (unionSize > 0) {
+      morphologyScore += 0.4 * (intersections / unionSize);
+    }
+
+    // 3. Spectral Score (similarity of FFT magnitude spectra)
+    const specQ = this.spectral.spectralTransform(queryRepr);
+    const specC = this.spectral.spectralTransform(candidateRepr);
+    const spectralScore = this.spectral.spectralSimilarity(specQ, specC);
+
+    // 4. Phase Score (phase coherence between vectors)
+    const phaseScore = this.phase.phaseCoherence(queryRepr, candidateRepr);
+
+    // 5. Context Score (simple character-length ratio/exact overlaps)
+    let contextScore = 0.0;
+    if (morphQ.harmony === morphC.harmony) {
+      contextScore += 0.5; // same vowel harmony category
+    }
+    const lenDiff = Math.abs(query.length - candidate.length);
+    contextScore += 0.5 * Math.max(0, 1 - lenDiff / Math.max(query.length, candidate.length, 1));
+
+    // Calculate final weighted compound resonance
+    const finalScore = 
+      this.alpha * semanticScore +
+      this.beta * morphologyScore +
+      this.gamma * spectralScore +
+      this.delta * phaseScore +
+      this.epsilon * contextScore;
+
+    return {
+      finalScore,
+      breakdown: {
+        semantic: semanticScore,
+        morphology: morphologyScore,
+        spectral: spectralScore,
+        phase: phaseScore,
+        context: contextScore
+      }
+    };
+  }
+
+  generateSignature(id, representation, text = '') {
+    const spec = this.spectral.spectralTransform(representation);
+    const energy = this.spectral.spectralEnergy(spec);
+    const entropy = this.spectral.spectralEntropy(spec);
+    const dominantFreq = this.spectral.extractDominantFrequencies(spec, 5);
+
+    const morph = this.morphology.analyze(text || id);
+
+    return {
+      id,
+      dimension: representation.D,
+      amplitude: spec.magnitude,
+      phase: spec.phase,
+      dominant_frequencies: dominantFreq,
+      spectral_energy: energy,
+      spectral_entropy: entropy,
+      morphology_signature: {
+        root: morph.root,
+        morphemes: morph.morphemes,
+        features: morph.features
+      },
+      timestamp: Date.now()
+    };
+  }
+}

package/core/safetensors.js

@@ -0,0 +1,62 @@
+/**
+ * Safetensors Parser Module
+ * Parsers HuggingFace .safetensors files natively in JavaScript.
+ * Read more: https://github.com/huggingface/safetensors
+ */
+
+import fs from 'fs';
+
+export class SafetensorsParser {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.fd = null;
+    this.header = {};
+    this.headerLength = 0;
+  }
+
+  open() {
+    this.fd = fs.openSync(this.filePath, 'r');
+    
+    // 1. Read first 8 bytes for header length (uint64 little endian)
+    const lenBuf = Buffer.alloc(8);
+    fs.readSync(this.fd, lenBuf, 0, 8, 0);
+    
+    // Convert to number (safe for safe-tensors headers < 9PB)
+    this.headerLength = Number(lenBuf.readBigUInt64LE(0));
+    
+    // 2. Read JSON header
+    const headerBuf = Buffer.alloc(this.headerLength);
+    fs.readSync(this.fd, headerBuf, 0, this.headerLength, 8);
+    this.header = JSON.parse(headerBuf.toString('utf8'));
+  }
+
+  getTensorNames() {
+    return Object.keys(this.header).filter(key => key !== '__metadata__');
+  }
+
+  readTensor(tensorName) {
+    const meta = this.header[tensorName];
+    if (!meta) return null;
+
+    const [start, end] = meta.data_offsets;
+    const byteLength = end - start;
+    
+    const dataBuf = Buffer.alloc(byteLength);
+    // Offset in file is: 8 (length field) + headerLength + start_offset
+    fs.readSync(this.fd, dataBuf, 0, byteLength, 8 + this.headerLength + start);
+
+    if (meta.dtype === 'F32') {
+      // Float32 arrays are 4 bytes per element
+      return new Float32Array(dataBuf.buffer, dataBuf.byteOffset, byteLength / 4);
+    }
+    
+    return dataBuf;
+  }
+
+  close() {
+    if (this.fd) {
+      fs.closeSync(this.fd);
+      this.fd = null;
+    }
+  }
+}

package/core/sovereign_agent.js

@@ -0,0 +1,164 @@
+/**
+ * Sovereign Autonomous Agent Module
+ * Implements a fully local ReAct (Reasoning + Acting) otonom loop 
+ * powered by local tools and deterministic task planning.
+ */
+
+import { evaluateMath } from './reasoning_router.js';
+
+export class SovereignAgent {
+  /**
+   * @param {Object} sdkInstance - The ResonanceSDK instance containing hdc, memory, router, morphology
+   */
+  constructor(sdkInstance) {
+    this.sdk = sdkInstance;
+    this.memory = sdkInstance ? sdkInstance.memory : null;
+    this.morphology = sdkInstance ? sdkInstance.morphology : null;
+    this.router = sdkInstance ? sdkInstance.router : null;
+    
+    // Wire up available otonom tools
+    this.tools = {
+      memory_lookup: (query) => {
+        if (!this.memory) return "Hata: Bellek motoru yüklü değil.";
+        const vec = this.router ? this.router.vectorize(query) : new Float32Array(1024);
+        const results = this.memory.retrieve(vec, 1);
+        if (results.length === 0) return "Bulunamadı.";
+        return results[0].record.content;
+      },
+      math_eval: (expr) => {
+        try {
+          return evaluateMath(expr).toString();
+        } catch (e) {
+          return `Hata: Matematiksel hesaplama başarısız. ${e.message}`;
+        }
+      },
+      morphology_analyze: (word) => {
+        if (!this.morphology) return "Hata: Morfoloji motoru yüklü değil.";
+        const analysis = this.morphology.analyze(word);
+        return JSON.stringify({
+          root: analysis.root,
+          suffixes: analysis.suffixes,
+          harmony: analysis.harmony,
+          syllables: analysis.syllables
+        });
+      },
+      spectral_transform: (text) => {
+        if (!this.sdk || !this.sdk.spectral) return "Hata: Spektral motor yüklü değil.";
+        const vec = this.router ? this.router.vectorize(text) : new Float32Array(1024);
+        const spec = this.sdk.spectral.spectralTransform({ type: 'real', values: vec, D: vec.length });
+        return `Energy: ${spec.magnitude.reduce((a, b) => a + b, 0).toFixed(2)}`;
+      },
+      system_time: () => {
+        return new Date().toISOString();
+      }
+    };
+  }
+
+  /**
+   * Run the ReAct autonomous execution loop
+   * @param {string} goal - The user prompt/objective
+   * @param {number} [maxSteps=5] - Maximum execution steps
+   * @returns {Promise<Object>} Execution log and final answer
+   */
+  async execute(goal, maxSteps = 5) {
+    const logs = [];
+    let step = 1;
+    let finished = false;
+    let finalAnswer = "";
+
+    // Local planner parsing key intents from query
+    const lowerGoal = goal.toLowerCase();
+
+    while (step <= maxSteps && !finished) {
+      let thought = "";
+      let action = "";
+      let actionArg = "";
+
+      // Step-by-step reasoning path determined based on goal context
+      if (lowerGoal.includes("hatırla") || lowerGoal.includes("hafıza") || lowerGoal.includes("favori")) {
+        if (step === 1) {
+          thought = "Kullanıcının sorduğu favori veya bellek kaydını bulmak için hafızada arama yapmalıyım.";
+          action = "memory_lookup";
+          // extract likely key query
+          actionArg = lowerGoal.includes("renk") ? "favori renk" : "hafıza sorgusu";
+        } else if (step === 2) {
+          const prevObs = logs[0].observation;
+          thought = `Hafızadan '${prevObs}' bilgisini aldım. Bu kelimeyi morfolojik olarak analiz etmeliyim.`;
+          action = "morphology_analyze";
+          actionArg = prevObs.split(/\s+/).pop().replace(/[^a-zçgğıoöşuüâîû]/g, '');
+        } else {
+          const prevObs = logs[1].observation;
+          thought = "Gerekli aramaları ve analizleri tamamladım. Sonucu kullanıcıya sunuyorum.";
+          finished = true;
+          finalAnswer = `Otonom ReAct Görevi Başarıyla Tamamlandı.\n` + 
+                      `- Hafıza Kaydı: ${logs[0].observation}\n` +
+                      `- Morfolojik Yapı: ${prevObs}`;
+        }
+      } else if (lowerGoal.includes("hesapla") || /[0-9+\-*/%^]/.test(lowerGoal)) {
+        if (step === 1) {
+          thought = "Matematiksel ifadeyi deterministik parser ile hesaplamalıyım.";
+          action = "math_eval";
+          // extract arithmetic expression
+          const match = goal.match(/[0-9+\-*/%^().\s]+/);
+          actionArg = match ? match[0].trim() : "0";
+        } else if (step === 2) {
+          const val = logs[0].observation;
+          thought = `Hesaplanan '${val}' sonucunun spektral enerji yoğunluğunu kontrol etmeliyim.`;
+          action = "spectral_transform";
+          actionArg = val;
+        } else {
+          thought = "Hesaplama ve spektral dönüşüm adımları bitti. Sonucu dönüyorum.";
+          finished = true;
+          finalAnswer = `Hesaplama Sonucu: ${logs[0].observation} | Spektral Temsiliyet: ${logs[1].observation}`;
+        }
+      } else {
+        // Generic default task path
+        if (step === 1) {
+          thought = "Sistem saatini alarak güncel zamanı kontrol etmeliyim.";
+          action = "system_time";
+          actionArg = "";
+        } else {
+          thought = "Varsayılan otonom akış tamamlandı.";
+          finished = true;
+          finalAnswer = `Mevcut Zaman Dilimi: ${logs[0].observation}`;
+        }
+      }
+
+      if (!finished) {
+        // Execute tool action
+        let observation = "";
+        const toolFn = this.tools[action];
+        if (toolFn) {
+          observation = toolFn(actionArg);
+        } else {
+          observation = `Hata: '${action}' aracı tanımlı değil.`;
+        }
+
+        logs.push({
+          step,
+          thought,
+          action,
+          argument: actionArg,
+          observation
+        });
+        
+        step++;
+      } else {
+        logs.push({
+          step,
+          thought,
+          action: "final_answer",
+          argument: "",
+          observation: finalAnswer
+        });
+      }
+    }
+
+    return {
+      goal,
+      stepsRun: step - 1,
+      logs,
+      finalAnswer
+    };
+  }
+}

package/core/spectral.js

@@ -0,0 +1,259 @@
+/**
+ * Spectral Computing Engine
+ * Implements Radix-2 Cooley-Tukey FFT / IFFT and spectral feature analysis.
+ */
+
+import { Representation } from './hdc.js';
+
+export class SpectralEngine {
+  constructor() {}
+
+  // ── FFT CORE ALGORITHMS ────────────────────────────────────
+
+  _bitReverse(re, im) {
+    const n = re.length;
+    let j = 0;
+    for (let i = 0; i < n; i++) {
+      if (i < j) {
+        let temp = re[i]; re[i] = re[j]; re[j] = temp;
+        temp = im[i]; im[i] = im[j]; im[j] = temp;
+      }
+      let m = n >> 1;
+      while (m >= 2 && j >= m) {
+        j -= m;
+        m >>= 1;
+      }
+      j += m;
+    }
+  }
+
+  _fftCore(re, im, inverse = false) {
+    const n = re.length;
+    this._bitReverse(re, im);
+
+    for (let len = 2; len <= n; len <<= 1) {
+      const angle = (2 * Math.PI / len) * (inverse ? 1 : -1);
+      const wlen_re = Math.cos(angle);
+      const wlen_im = Math.sin(angle);
+
+      for (let i = 0; i < n; i += len) {
+        let w_re = 1.0;
+        let w_im = 0.0;
+        const half = len >> 1;
+
+        for (let j = 0; j < half; j++) {
+          const u_re = re[i + j];
+          const u_im = im[i + j];
+          
+          const t_re = re[i + j + half];
+          const t_im = im[i + j + half];
+          
+          const v_re = t_re * w_re - t_im * w_im;
+          const v_im = t_re * w_im + t_im * w_re;
+
+          re[i + j] = u_re + v_re;
+          im[i + j] = u_im + v_im;
+          
+          re[i + j + half] = u_re - v_re;
+          im[i + j + half] = u_im - v_im;
+
+          const next_w_re = w_re * wlen_re - w_im * wlen_im;
+          const next_w_im = w_re * wlen_im + w_im * wlen_re;
+          w_re = next_w_re;
+          w_im = next_w_im;
+        }
+      }
+    }
+
+    if (inverse) {
+      for (let i = 0; i < n; i++) {
+        re[i] /= n;
+        im[i] /= n;
+      }
+    }
+  }
+
+  // ── EXTERNAL API ───────────────────────────────────────────
+
+  spectralTransform(representation) {
+    const D = representation.D;
+    const re = new Float32Array(D);
+    const im = new Float32Array(D);
+
+    // Map different representation formats into complex domain
+    if (representation.type === 'complex') {
+      // Phase-coded: z = e^{i * theta}
+      for (let i = 0; i < D; i++) {
+        re[i] = Math.cos(representation.values[i]);
+        im[i] = Math.sin(representation.values[i]);
+      }
+    } else if (representation.type === 'bipolar' || representation.type === 'real') {
+      // Real-valued: z = x + 0i
+      for (let i = 0; i < D; i++) {
+        re[i] = representation.values[i];
+        im[i] = 0.0;
+      }
+    } else if (representation.type === 'binary') {
+      // Map 0 -> -1, 1 -> 1
+      for (let i = 0; i < D; i++) {
+        re[i] = representation.values[i] === 1 ? 1.0 : -1.0;
+        im[i] = 0.0;
+      }
+    }
+
+    // Run FFT in-place
+    this._fftCore(re, im, false);
+
+    // Calculate magnitude and phase spectrum
+    const magnitude = new Float32Array(D);
+    const phase = new Float32Array(D);
+    for (let i = 0; i < D; i++) {
+      magnitude[i] = Math.sqrt(re[i] * re[i] + im[i] * im[i]);
+      phase[i] = Math.atan2(im[i], re[i]);
+    }
+
+    return {
+      type: representation.type,
+      D,
+      re,
+      im,
+      magnitude,
+      phase
+    };
+  }
+
+  inverseSpectralTransform(spectrum) {
+    const D = spectrum.D;
+    const re = new Float32Array(spectrum.re);
+    const im = new Float32Array(spectrum.im);
+
+    // Run IFFT in-place
+    this._fftCore(re, im, true);
+
+    // Reconstruct the original representation type
+    if (spectrum.type === 'complex') {
+      const vals = new Float32Array(D);
+      for (let i = 0; i < D; i++) {
+        let v = Math.atan2(im[i], re[i]);
+        if (v < 0) v += 2 * Math.PI;
+        vals[i] = v;
+      }
+      return new Representation('complex', vals, D);
+    }
+
+    if (spectrum.type === 'binary') {
+      const vals = new Uint8Array(D);
+      for (let i = 0; i < D; i++) {
+        vals[i] = re[i] >= 0.0 ? 1 : 0;
+      }
+      return new Representation('binary', vals, D);
+    }
+
+    if (spectrum.type === 'bipolar') {
+      const vals = new Float32Array(D);
+      for (let i = 0; i < D; i++) {
+        vals[i] = re[i] >= 0.0 ? 1.0 : -1.0;
+      }
+      return new Representation('bipolar', vals, D);
+    }
+
+    // Real representation fallback
+    const vals = new Float32Array(D);
+    for (let i = 0; i < D; i++) {
+      vals[i] = re[i];
+    }
+    return new Representation('real', vals, D);
+  }
+
+  extractDominantFrequencies(spectrum, k = 10) {
+    const n = spectrum.D;
+    const items = [];
+    for (let i = 0; i < n; i++) {
+      items.push({ freq: i, mag: spectrum.magnitude[i] });
+    }
+    // Sort descending by magnitude
+    items.sort((a, b) => b.mag - a.mag);
+    return items.slice(0, k);
+  }
+
+  spectralEnergy(spectrum) {
+    let energy = 0;
+    const n = spectrum.D;
+    for (let i = 0; i < n; i++) {
+      energy += spectrum.magnitude[i] * spectrum.magnitude[i];
+    }
+    return energy;
+  }
+
+  spectralEntropy(spectrum) {
+    const n = spectrum.D;
+    const power = new Float32Array(n);
+    let totalPower = 0;
+    for (let i = 0; i < n; i++) {
+      power[i] = spectrum.magnitude[i] * spectrum.magnitude[i];
+      totalPower += power[i];
+    }
+    if (totalPower === 0) return 0.0;
+
+    let entropy = 0.0;
+    for (let i = 0; i < n; i++) {
+      const p = power[i] / totalPower;
+      if (p > 0) {
+        entropy -= p * Math.log2(p);
+      }
+    }
+    // Normalized by log2(n)
+    return entropy / Math.log2(n);
+  }
+
+  spectralSparsity(spectrum) {
+    // Hoyer sparsity measure: (sqrt(n) - L1/L2) / (sqrt(n) - 1)
+    const n = spectrum.D;
+    let l1 = 0;
+    let l2Sq = 0;
+    for (let i = 0; i < n; i++) {
+      l1 += spectrum.magnitude[i];
+      l2Sq += spectrum.magnitude[i] * spectrum.magnitude[i];
+    }
+    const l2 = Math.sqrt(l2Sq);
+    if (l2 === 0) return 0.0;
+
+    const sqrtN = Math.sqrt(n);
+    return (sqrtN - l1 / l2) / (sqrtN - 1.0);
+  }
+
+  lowFrequencyEnergy(spectrum) {
+    // Energy in the lower half of spectrum frequencies
+    let energy = 0;
+    const half = Math.floor(spectrum.D / 2);
+    const quarter = Math.floor(half / 2);
+    for (let i = 0; i < quarter; i++) {
+      energy += spectrum.magnitude[i] * spectrum.magnitude[i];
+    }
+    return energy;
+  }
+
+  highFrequencyEnergy(spectrum) {
+    let energy = 0;
+    const half = Math.floor(spectrum.D / 2);
+    const quarter = Math.floor(half / 2);
+    for (let i = quarter; i < half; i++) {
+      energy += spectrum.magnitude[i] * spectrum.magnitude[i];
+    }
+    return energy;
+  }
+
+  spectralSimilarity(a, b) {
+    if (a.D !== b.D) return 0.0;
+    // Cosine similarity of magnitude spectra
+    let dot = 0, normA = 0, normB = 0;
+    const n = a.D;
+    for (let i = 0; i < n; i++) {
+      dot += a.magnitude[i] * b.magnitude[i];
+      normA += a.magnitude[i] * a.magnitude[i];
+      normB += b.magnitude[i] * b.magnitude[i];
+    }
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    return denom > 0 ? dot / denom : 0.0;
+  }
+}