@aleph-ai/tinyaleph 1.0.0

package/core/index.js

@@ -0,0 +1,133 @@
+/**
+ * Core mathematical foundation - exports all core modules
+ */
+
+const { Hypercomplex } = require('./hypercomplex');
+const {
+  FANO_LINES,
+  octonionMultiplyIndex,
+  sedenionMultiplyIndex,
+  multiplyIndices,
+  buildMultiplicationTable
+} = require('./fano');
+const {
+  primeGenerator, nthPrime, primesUpTo, isPrime,
+  factorize, primeSignature, firstNPrimes,
+  GaussianInteger, EisensteinInteger,
+  primeToFrequency, primeToAngle, sumOfTwoSquares,
+  DEFAULT_PRIMES
+} = require('./prime');
+const LLM = require('./llm');
+
+// Prime Hilbert Space (complex amplitudes, quantum-like)
+const {
+  Complex,
+  PrimeState,
+  ResonanceOperators,
+  EntropyDrivenEvolution,
+  encodeMemory,
+  symbolicCompute
+} = require('./hilbert');
+
+// Prime Resonance Network components
+const {
+  PHI, PHI_CONJ, DELTA_S,
+  QuaternionPrime,
+  PrimeResonanceIdentity,
+  PhaseLockedRing,
+  HolographicField,
+  EntangledNode,
+  ResonantFragment
+} = require('./resonance');
+
+// ResoFormer ML primitives
+const {
+  Quaternion,
+  SparsePrimeState,
+  resonanceScore,
+  resonantAttention,
+  hamiltonCompose,
+  measureNonCommutativity,
+  computeCoherence,
+  haltingDecision,
+  coherenceGatedCompute,
+  EntropyCollapseHead,
+  generateAttractorCodebook,
+  PRGraphMemory,
+  applyResonanceOperator
+} = require('./rformer');
+
+// TensorFlow.js layers (lazy load - may not be available)
+let rformerTF = null;
+try {
+  rformerTF = require('./rformer-tf');
+} catch (e) {
+  // TensorFlow.js not available, skip
+}
+
+module.exports = {
+  // Hypercomplex algebra
+  Hypercomplex,
+  
+  // Fano plane / multiplication
+  FANO_LINES,
+  octonionMultiplyIndex,
+  sedenionMultiplyIndex,
+  multiplyIndices,
+  buildMultiplicationTable,
+  
+  // Prime utilities
+  primeGenerator,
+  nthPrime,
+  primesUpTo,
+  isPrime,
+  factorize,
+  primeSignature,
+  firstNPrimes,
+  GaussianInteger,
+  EisensteinInteger,
+  primeToFrequency,
+  primeToAngle,
+  sumOfTwoSquares,
+  DEFAULT_PRIMES,
+  
+  // LLM client
+  LLM,
+  
+  // Prime Hilbert Space (HP)
+  Complex,
+  PrimeState,
+  ResonanceOperators,
+  EntropyDrivenEvolution,
+  encodeMemory,
+  symbolicCompute,
+  
+  // Prime Resonance Network
+  PHI,
+  PHI_CONJ,
+  DELTA_S,
+  QuaternionPrime,
+  PrimeResonanceIdentity,
+  PhaseLockedRing,
+  HolographicField,
+  EntangledNode,
+  ResonantFragment,
+  
+  // ResoFormer ML Primitives
+  Quaternion,
+  SparsePrimeState,
+  resonanceScore,
+  resonantAttention,
+  hamiltonCompose,
+  measureNonCommutativity,
+  computeCoherence,
+  haltingDecision,
+  coherenceGatedCompute,
+  EntropyCollapseHead,
+  generateAttractorCodebook,
+  PRGraphMemory,
+  applyResonanceOperator,
+  
+  // TensorFlow.js ResoFormer layers (if available)
+  ...(rformerTF || {})
+};

package/core/llm.js

@@ -0,0 +1,132 @@
+/**
+ * LMStudio LLM Client
+ * Calls LMStudio's OpenAI-compatible chat endpoint
+ */
+
+const DEFAULT_URL = 'http://192.168.4.79:1234/v1/chat/completions';
+const DEFAULT_MODEL = 'openai/gpt-oss-20b';
+
+let _baseUrl = DEFAULT_URL;
+let _model = DEFAULT_MODEL;
+
+/**
+ * Configure LMStudio connection
+ * @param {Object} cfg - Configuration
+ * @param {string} cfg.baseUrl - Base URL (default: http://localhost:1234/v1/chat/completions)
+ * @param {string} cfg.model - Model name (default: local-model)
+ */
+const configure = (cfg = {}) => {
+  if (cfg.baseUrl) _baseUrl = cfg.baseUrl;
+  if (cfg.model) _model = cfg.model;
+};
+
+/**
+ * Call LMStudio chat endpoint
+ * @param {Array<{role: string, content: string}>} messages - Conversation messages
+ * @param {Object} options - Generation options
+ * @param {number} options.temperature - Sampling temperature (0-2)
+ * @param {Object} options.jsonSchema - JSON schema for structured output
+ * @param {number} options.maxTokens - Maximum tokens to generate
+ * @returns {Promise<{content: string, usage: Object, raw: Object}>}
+ */
+async function chat(messages, options = {}) {
+  const { temperature = 0.7, jsonSchema = null, maxTokens = 1024 } = options;
+
+  const body = {
+    model: _model,
+    messages,
+    temperature,
+    max_tokens: maxTokens,
+    stream: false
+  };
+
+  // Add JSON schema if provided (structured output)
+  if (jsonSchema) {
+    // Adapt to LMStudio/OpenAI Structured Outputs requirement
+    body.response_format = {
+      type: 'json_schema',
+      json_schema: {
+        name: 'response',
+        schema: jsonSchema
+      }
+    };
+  }
+
+  const res = await fetch(_baseUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body)
+  });
+
+  if (!res.ok) {
+    const err = await res.text().catch(() => 'Unknown error');
+    throw new Error(`LMStudio error (${res.status}): ${err}`);
+  }
+
+  const data = await res.json();
+  const choice = data.choices?.[0];
+  
+  if (!choice) throw new Error('No response from LMStudio');
+
+  let content = choice.message?.content || '';
+  
+  // Parse JSON if schema was requested
+  if (jsonSchema && content) {
+    try {
+      content = JSON.parse(content);
+    } catch (e) {
+      // Return raw string if JSON parse fails
+    }
+  }
+
+  return {
+    content,
+    usage: data.usage || {},
+    raw: data
+  };
+}
+
+/**
+ * Simple completion helper
+ * @param {string} prompt - User prompt
+ * @param {Object} options - Generation options
+ * @returns {Promise<string>}
+ */
+async function complete(prompt, options = {}) {
+  const r = await chat([{ role: 'user', content: prompt }], options);
+  return r.content;
+}
+
+/**
+ * System + user message helper
+ * @param {string} system - System prompt
+ * @param {string} user - User message
+ * @param {Object} options - Generation options
+ * @returns {Promise<string>}
+ */
+async function ask(system, user, options = {}) {
+  const r = await chat([
+    { role: 'system', content: system },
+    { role: 'user', content: user }
+  ], options);
+  return r.content;
+}
+
+/**
+ * Check if LMStudio is running
+ * @returns {Promise<boolean>}
+ */
+async function ping() {
+  try {
+    const r = await fetch(_baseUrl.replace('/chat/completions', '/models'));
+    return r.ok;
+  } catch { return false; }
+}
+
+/**
+ * Get current configuration
+ * @returns {{baseUrl: string, model: string}}
+ */
+const getConfig = () => ({ baseUrl: _baseUrl, model: _model });
+
+module.exports = { chat, complete, ask, configure, ping, getConfig };

package/core/prime.js

@@ -0,0 +1,184 @@
+/**
+ * Prime number utilities for encoding and cryptographic operations
+ */
+
+// Prime generation
+function* primeGenerator(start = 2) {
+  let n = start;
+  while (true) {
+    if (isPrime(n)) yield n;
+    n++;
+  }
+}
+
+function nthPrime(n) {
+  let count = 0, candidate = 2;
+  while (count < n) {
+    if (isPrime(candidate)) count++;
+    if (count < n) candidate++;
+  }
+  return candidate;
+}
+
+function primesUpTo(max) {
+  const sieve = new Array(max + 1).fill(true);
+  sieve[0] = sieve[1] = false;
+  for (let i = 2; i * i <= max; i++) {
+    if (sieve[i]) {
+      for (let j = i * i; j <= max; j += i) sieve[j] = false;
+    }
+  }
+  return sieve.map((v, i) => v ? i : 0).filter(Boolean);
+}
+
+function isPrime(n) {
+  if (n < 2) return false;
+  if (n === 2) return true;
+  if (n % 2 === 0) return false;
+  for (let i = 3, s = Math.sqrt(n); i <= s; i += 2) {
+    if (n % i === 0) return false;
+  }
+  return true;
+}
+
+// Factorization
+function factorize(n) {
+  const factors = {};
+  let d = 2;
+  while (n > 1) {
+    while (n % d === 0) {
+      factors[d] = (factors[d] || 0) + 1;
+      n /= d;
+    }
+    d++;
+    if (d * d > n && n > 1) {
+      factors[n] = (factors[n] || 0) + 1;
+      break;
+    }
+  }
+  return factors;
+}
+
+function primeSignature(primes) {
+  return [...primes].sort((a, b) => a - b).join(',');
+}
+
+// Gaussian Integers (Z[i])
+class GaussianInteger {
+  constructor(real, imag) {
+    this.real = real;
+    this.imag = imag;
+  }
+  
+  norm() { return this.real ** 2 + this.imag ** 2; }
+  
+  add(other) {
+    return new GaussianInteger(this.real + other.real, this.imag + other.imag);
+  }
+  
+  mul(other) {
+    return new GaussianInteger(
+      this.real * other.real - this.imag * other.imag,
+      this.real * other.imag + this.imag * other.real
+    );
+  }
+  
+  conjugate() {
+    return new GaussianInteger(this.real, -this.imag);
+  }
+  
+  isGaussianPrime() {
+    const n = this.norm();
+    if (!isPrime(n)) return false;
+    // Prime if norm is prime and not split
+    return n % 4 === 3 || (this.real !== 0 && this.imag !== 0);
+  }
+  
+  toString() {
+    if (this.imag === 0) return `${this.real}`;
+    if (this.real === 0) return `${this.imag}i`;
+    const sign = this.imag > 0 ? '+' : '';
+    return `${this.real}${sign}${this.imag}i`;
+  }
+}
+
+// Eisenstein Integers (Z[ω] where ω = e^(2πi/3))
+class EisensteinInteger {
+  constructor(a, b) {
+    this.a = a;  // a + b*ω
+    this.b = b;
+  }
+  
+  norm() { return this.a ** 2 - this.a * this.b + this.b ** 2; }
+  
+  add(other) {
+    return new EisensteinInteger(this.a + other.a, this.b + other.b);
+  }
+  
+  mul(other) {
+    return new EisensteinInteger(
+      this.a * other.a - this.b * other.b,
+      this.a * other.b + this.b * other.a - this.b * other.b
+    );
+  }
+  
+  conjugate() {
+    return new EisensteinInteger(this.a - this.b, -this.b);
+  }
+  
+  isEisensteinPrime() {
+    const n = this.norm();
+    return isPrime(n) && n % 3 === 2;
+  }
+  
+  toString() {
+    if (this.b === 0) return `${this.a}`;
+    if (this.a === 0) return `${this.b}ω`;
+    const sign = this.b > 0 ? '+' : '';
+    return `${this.a}${sign}${this.b}ω`;
+  }
+}
+
+// Prime-to-angle mapping (PRSC formula)
+function primeToFrequency(p, base = 1, logScale = 10) {
+  return base + Math.log(p) / logScale;
+}
+
+function primeToAngle(p) {
+  return (360 / p) * (Math.PI / 180);
+}
+
+// Sum of two squares representation (for p ≡ 1 mod 4)
+function sumOfTwoSquares(p) {
+  if (p === 2) return [1, 1];
+  if (p % 4 !== 1) return null;
+  
+  for (let a = 1; a * a <= p; a++) {
+    const b2 = p - a * a;
+    const b = Math.sqrt(b2);
+    if (b === Math.floor(b)) return [a, b];
+  }
+  return null;
+}
+
+// Generate first N primes
+function firstNPrimes(n) {
+  const primes = [];
+  let candidate = 2;
+  while (primes.length < n) {
+    if (isPrime(candidate)) primes.push(candidate);
+    candidate++;
+  }
+  return primes;
+}
+
+// Default prime list (first 100 primes)
+const DEFAULT_PRIMES = firstNPrimes(100);
+
+module.exports = {
+  primeGenerator, nthPrime, primesUpTo, isPrime,
+  factorize, primeSignature, firstNPrimes,
+  GaussianInteger, EisensteinInteger,
+  primeToFrequency, primeToAngle, sumOfTwoSquares,
+  DEFAULT_PRIMES
+};