thyscript 1.0.0

package/src/runtime/ThyRuntime.js

@@ -0,0 +1,265 @@
+'use strict';
+/**
+ * ThyScript Runtime Engine
+ * Central runtime orchestrator for ThyScript execution.
+ * Manages memory, V8 garbage collection, server preprocessing,
+ * mathematical preprocessing, multi-core clustering, and standard library bindings.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const readline = require('readline');
+const cluster = require('cluster');
+const os = require('os');
+const v8 = require('v8');
+const vm = require('vm');
+const { performance } = require('perf_hooks');
+
+const MathLib = require('./stdlib/MathLib');
+const StringLib = require('./stdlib/StringLib');
+const ArrayLib = require('./stdlib/ArrayLib');
+const FileLib = require('./stdlib/FileLib');
+const MemoryManager = require('../memory/MemoryManager');
+const ServerEngine = require('../server/ServerEngine');
+const SecurityEngine = require('../server/SecurityEngine');
+const HTMLCSSEngine = require('../server/HTMLCSSEngine');
+const DatabaseEngine = require('../database/DatabaseEngine');
+
+class ThyRuntime {
+  constructor(options = {}) {
+    this.options = Object.assign({
+      cores: Math.min(4, os.cpus().length || 4),
+      enableClustering: false,
+      memoryLimitMB: 512,
+      saveDir: process.cwd(),
+      verbose: false,
+    }, options);
+
+    this.memoryManager = new MemoryManager({
+      limitMB: this.options.memoryLimitMB,
+      onHighMemory: (stats) => {
+        if (this.options.verbose) {
+          console.warn(`[ThyScript Runtime] High memory usage: ${stats.heapUsedMB} MB / ${this.options.memoryLimitMB} MB`);
+        }
+        this.runGarbageCollector();
+      },
+    });
+
+    this.serverEngine = new ServerEngine();
+    this.securityEngine = new SecurityEngine();
+    this.htmlCssEngine = new HTMLCSSEngine();
+    this.databaseEngine = new DatabaseEngine();
+    this.mathLib = new MathLib();           // instance methods
+    this.stringLib = new StringLib();       // instance methods
+    this.arrayLib = ArrayLib;               // static methods → expose the class
+    this.fileLib = FileLib;                 // static methods → expose the class
+
+    this._stateStore = new Map();
+    this._initialized = false;
+  }
+
+  /**
+   * Initialize all runtime subsystems
+   */
+  async init() {
+    if (this._initialized) return this;
+
+    // Start memory monitoring
+    this.memoryManager.startMonitoring(5000);
+
+    // Initialize 4-core cluster if requested
+    if (this.options.enableClustering && cluster.isPrimary) {
+      const numCores = this.options.cores;
+      for (let i = 0; i < numCores; i++) {
+        cluster.fork();
+      }
+      cluster.on('exit', (worker, code, signal) => {
+        if (this.options.verbose) {
+          console.log(`[ThyScript Cluster] Worker ${worker.process.pid} exited. Respawning...`);
+        }
+        cluster.fork();
+      });
+    }
+
+    this._initialized = true;
+    return this;
+  }
+
+  /**
+   * Run garbage collection (uses V8 global.gc if available, else clears internal caches)
+   */
+  runGarbageCollector() {
+    if (global.gc) {
+      try {
+        global.gc();
+      } catch (_) {}
+    }
+    // Clean internal state store of stale entries
+    if (this._stateStore.size > 10000) {
+      this._stateStore.clear();
+    }
+  }
+
+  /**
+   * Prompt user for input via readline (async)
+   */
+  async promptInput(promptText = '') {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    return new Promise((resolve) => {
+      rl.question(promptText ? `${promptText} ` : '> ', (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    });
+  }
+
+  /**
+   * Persist variable or state to disk (.thysave file)
+   */
+  saveState(key, value) {
+    this._stateStore.set(key, value);
+    const savePath = path.join(this.options.saveDir, `${key}.thysave`);
+    try {
+      fs.writeFileSync(savePath, JSON.stringify(value, null, 2), 'utf8');
+      return true;
+    } catch (e) {
+      console.warn(`[ThyScript] Failed to persist state '${key}': ${e.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Load persisted variable from disk
+   */
+  loadState(key) {
+    if (this._stateStore.has(key)) return this._stateStore.get(key);
+    const savePath = path.join(this.options.saveDir, `${key}.thysave`);
+    if (fs.existsSync(savePath)) {
+      try {
+        const data = JSON.parse(fs.readFileSync(savePath, 'utf8'));
+        this._stateStore.set(key, data);
+        return data;
+      } catch (_) {
+        return null;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Free an object or variable from memory (hint for garbage collection)
+   */
+  freeVariable(obj) {
+    if (obj && typeof obj === 'object') {
+      if (Array.isArray(obj)) {
+        obj.length = 0;
+      } else {
+        for (const k of Object.keys(obj)) {
+          delete obj[k];
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * High-speed math preprocessing and evaluation (target: sub-1ms)
+   */
+  calculate(expr) {
+    if (typeof expr === 'number') return expr;
+    if (typeof expr !== 'string') return expr;
+    try {
+      return (new Function('Math', `return (${expr});`))(Math);
+    } catch (e) {
+      return this.mathLib.calculate(expr);
+    }
+  }
+
+  /**
+   * Print helper with formatting support
+   */
+  print(...args) {
+    const formatted = args.map((arg) => {
+      if (arg === null) return 'null';
+      if (arg === undefined) return 'undefined';
+      if (typeof arg === 'object') {
+        try {
+          return JSON.stringify(arg, null, 2);
+        } catch (_) {
+          return String(arg);
+        }
+      }
+      return String(arg);
+    });
+    console.log(...formatted);
+  }
+
+  /**
+   * Build execution sandbox context with all ThyScript standard library functions
+   */
+  buildContext(customContext = {}) {
+    const runtime = this;
+
+    return {
+      // Core I/O
+      print: (...args) => runtime.print(...args),
+      input: (prompt) => runtime.promptInput(prompt),
+      save: (key, val) => runtime.saveState(key, val),
+      load: (key) => runtime.loadState(key),
+      free: (val) => runtime.freeVariable(val),
+      calculate: (expr) => runtime.calculate(expr),
+
+      // Internal compiler bindings
+      __thy_print: (...args) => runtime.print(...args),
+      __thy_input: (prompt) => runtime.promptInput(prompt),
+      __thy_save: (key, val) => runtime.saveState(key, val),
+      __thy_load: (key) => runtime.loadState(key),
+      __thy_free: (val) => runtime.freeVariable(val),
+      __thy_calculate: (expr) => runtime.calculate(expr),
+      __thy_sleep: (ms) => new Promise(r => setTimeout(r, ms)),
+      __thy_timer: () => performance.now(),
+
+      // Standard library packages
+      Math: Math,
+      math: runtime.mathLib,
+      string: runtime.stringLib,
+      array: runtime.arrayLib,
+      file: runtime.fileLib,
+      memory: runtime.memoryManager,
+      server: runtime.serverEngine,
+      security: runtime.securityEngine,
+      html: runtime.htmlCssEngine,
+      database: runtime.databaseEngine,
+
+      // Global constructors
+      Float64Array,
+      Float32Array,
+      Int32Array,
+      Uint8Array,
+      ArrayBuffer,
+      Map,
+      Set,
+      Promise,
+      Date,
+      RegExp,
+      JSON,
+      Buffer,
+
+      // Injected custom context
+      ...customContext,
+    };
+  }
+
+  /**
+   * Clean up runtime resources
+   */
+  destroy() {
+    this.memoryManager.stopMonitoring();
+    this.serverEngine.stop();
+  }
+}
+
+module.exports = ThyRuntime;

package/src/runtime/stdlib/ArrayLib.js

@@ -0,0 +1,207 @@
+'use strict';
+/**
+ * ThyScript Array Library
+ * High-performance array and collection manipulation functions
+ */
+
+class ThyArrayLib {
+  // ─── Functional Iterators ──────────────────────────────────────────────────
+  static map(arr, fn) { return arr.map(fn); }
+  static filter(arr, fn) { return arr.filter(fn); }
+  static reduce(arr, fn, init) { return init !== undefined ? arr.reduce(fn, init) : arr.reduce(fn); }
+  static forEach(arr, fn) { arr.forEach(fn); }
+  static find(arr, fn) { return arr.find(fn); }
+  static findIndex(arr, fn) { return arr.findIndex(fn); }
+  static some(arr, fn) { return arr.some(fn); }
+  static every(arr, fn) { return arr.every(fn); }
+  static includes(arr, val) { return arr.includes(val); }
+
+  // ─── Sorting & Shuffling ───────────────────────────────────────────────────
+  static sort(arr, fn) { return [...arr].sort(fn); }
+  static sortBy(arr, key) {
+    const fn = typeof key === 'function' ? key : (item) => item[key];
+    return [...arr].sort((a, b) => {
+      const va = fn(a), vb = fn(b);
+      return va < vb ? -1 : va > vb ? 1 : 0;
+    });
+  }
+  static sortDesc(arr) { return [...arr].sort((a, b) => b - a); }
+  static shuffle(arr) {
+    const result = [...arr];
+    for (let i = result.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+  }
+
+  // ─── Transformations ───────────────────────────────────────────────────────
+  static flatten(arr, depth = 1) { return arr.flat(depth); }
+  static flatMap(arr, fn) { return arr.flatMap(fn); }
+  static chunk(arr, size) {
+    const result = [];
+    for (let i = 0; i < arr.length; i += size) {
+      result.push(arr.slice(i, i + size));
+    }
+    return result;
+  }
+  static zip(...arrays) {
+    const maxLen = Math.max(...arrays.map(a => a.length));
+    const result = [];
+    for (let i = 0; i < maxLen; i++) {
+      result.push(arrays.map(a => a[i]));
+    }
+    return result;
+  }
+  static unzip(arr) {
+    if (!arr.length) return [];
+    return arr[0].map((_, i) => arr.map(row => row[i]));
+  }
+
+  // ─── Set Operations ────────────────────────────────────────────────────────
+  static unique(arr) { return [...new Set(arr)]; }
+  static uniqueBy(arr, key) {
+    const fn = typeof key === 'function' ? key : (item) => item[key];
+    const seen = new Set();
+    return arr.filter(item => {
+      const val = fn(item);
+      if (seen.has(val)) return false;
+      seen.add(val);
+      return true;
+    });
+  }
+  static intersect(a, b) {
+    const setB = new Set(b);
+    return a.filter(x => setB.has(x));
+  }
+  static union(a, b) { return [...new Set([...a, ...b])]; }
+  static difference(a, b) {
+    const setB = new Set(b);
+    return a.filter(x => !setB.has(x));
+  }
+
+  // ─── Grouping & Aggregation ────────────────────────────────────────────────
+  static groupBy(arr, key) {
+    const fn = typeof key === 'function' ? key : (item) => item[key];
+    return arr.reduce((acc, item) => {
+      const k = fn(item);
+      (acc[k] = acc[k] || []).push(item);
+      return acc;
+    }, {});
+  }
+  static countBy(arr, key) {
+    const fn = typeof key === 'function' ? key : (item) => item[key];
+    return arr.reduce((acc, item) => {
+      const k = fn(item);
+      acc[k] = (acc[k] || 0) + 1;
+      return acc;
+    }, {});
+  }
+  static partitionBy(arr, fn) {
+    const pass = [], fail = [];
+    for (const item of arr) {
+      (fn(item) ? pass : fail).push(item);
+    }
+    return [pass, fail];
+  }
+
+  // ─── Accessors ─────────────────────────────────────────────────────────────
+  static first(arr, n = 1) { return n === 1 ? arr[0] : arr.slice(0, n); }
+  static last(arr, n = 1) { return n === 1 ? arr[arr.length - 1] : arr.slice(-n); }
+  static nth(arr, n) { return n < 0 ? arr[arr.length + n] : arr[n]; }
+  static take(arr, n) { return arr.slice(0, n); }
+  static drop(arr, n) { return arr.slice(n); }
+  static dropRight(arr, n) { return arr.slice(0, -n); }
+
+  // ─── Math & Statistics ─────────────────────────────────────────────────────
+  static sum(arr) { return arr.reduce((acc, x) => acc + x, 0); }
+  static avg(arr) { return arr.length ? arr.reduce((acc, x) => acc + x, 0) / arr.length : 0; }
+  static min(arr) { return Math.min(...arr); }
+  static max(arr) { return Math.max(...arr); }
+  static minBy(arr, key) {
+    const fn = typeof key === 'function' ? key : (item) => item[key];
+    return arr.reduce((min, item) => fn(item) < fn(min) ? item : min, arr[0]);
+  }
+  static maxBy(arr, key) {
+    const fn = typeof key === 'function' ? key : (item) => item[key];
+    return arr.reduce((max, item) => fn(item) > fn(max) ? item : max, arr[0]);
+  }
+
+  // ─── Generation & Manipulation ─────────────────────────────────────────────
+  static range(start, end, step = 1) {
+    if (end === undefined) { end = start; start = 0; }
+    const result = [];
+    if (step > 0) {
+      for (let i = start; i < end; i += step) result.push(i);
+    } else {
+      for (let i = start; i > end; i += step) result.push(i);
+    }
+    return result;
+  }
+  static rotate(arr, n) {
+    const len = arr.length;
+    if (!len) return arr;
+    const offset = ((n % len) + len) % len;
+    return [...arr.slice(offset), ...arr.slice(0, offset)];
+  }
+  static reverse(arr) { return [...arr].reverse(); }
+  static compact(arr) { return arr.filter(Boolean); }
+
+  // ─── 2D Matrix Operations ──────────────────────────────────────────────────
+  static matrix2D(rows, cols, fillVal = 0) {
+    return Array.from({ length: rows }, () => new Array(cols).fill(fillVal));
+  }
+  static matrixTranspose(mat) {
+    if (!mat.length) return [];
+    return mat[0].map((_, c) => mat.map(row => row[c]));
+  }
+  static matrixMultiply(a, b) {
+    const rowsA = a.length, colsA = a[0].length, colsB = b[0].length;
+    const result = ThyArrayLib.matrix2D(rowsA, colsB, 0);
+    for (let i = 0; i < rowsA; i++) {
+      for (let j = 0; j < colsB; j++) {
+        let sum = 0;
+        for (let k = 0; k < colsA; k++) {
+          sum += a[i][k] * b[k][j];
+        }
+        result[i][j] = sum;
+      }
+    }
+    return result;
+  }
+
+  // ─── Algorithms ────────────────────────────────────────────────────────────
+  static binarySearch(arr, target, compareFn) {
+    let low = 0, high = arr.length - 1;
+    const cmp = compareFn || ((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    while (low <= high) {
+      const mid = (low + high) >> 1;
+      const c = cmp(arr[mid], target);
+      if (c === 0) return mid;
+      if (c < 0) low = mid + 1;
+      else high = mid - 1;
+    }
+    return -1;
+  }
+
+  static slidingWindow(arr, size, step = 1) {
+    const result = [];
+    for (let i = 0; i <= arr.length - size; i += step) {
+      result.push(arr.slice(i, i + size));
+    }
+    return result;
+  }
+
+  static movingAverage(arr, windowSize) {
+    const result = [];
+    let sum = 0;
+    for (let i = 0; i < arr.length; i++) {
+      sum += arr[i];
+      if (i >= windowSize) sum -= arr[i - windowSize];
+      if (i >= windowSize - 1) result.push(sum / windowSize);
+    }
+    return result;
+  }
+}
+
+module.exports = ThyArrayLib;

package/src/runtime/stdlib/FileLib.js

@@ -0,0 +1,168 @@
+'use strict';
+/**
+ * ThyScript File Library
+ * Comprehensive file system operations with async/sync APIs, streams, and compression
+ */
+
+const fs = require('fs');
+const path = require('path');
+const zlib = require('zlib');
+const { promisify } = require('util');
+
+const gzip = promisify(zlib.gzip);
+const gunzip = promisify(zlib.gunzip);
+
+class ThyFileLib {
+  // ─── Reading ───────────────────────────────────────────────────────────────
+  static async read(filePath, encoding = 'utf8') {
+    return fs.promises.readFile(path.resolve(filePath), encoding);
+  }
+
+  static readSync(filePath, encoding = 'utf8') {
+    return fs.readFileSync(path.resolve(filePath), encoding);
+  }
+
+  static async readJSON(filePath) {
+    const content = await ThyFileLib.read(filePath);
+    return JSON.parse(content);
+  }
+
+  static readJSONSync(filePath) {
+    return JSON.parse(ThyFileLib.readSync(filePath));
+  }
+
+  static async readLines(filePath, encoding = 'utf8') {
+    const content = await ThyFileLib.read(filePath, encoding);
+    return content.split(/\r?\n/);
+  }
+
+  // ─── Writing ───────────────────────────────────────────────────────────────
+  static async write(filePath, content, encoding = 'utf8') {
+    const resolved = path.resolve(filePath);
+    await fs.promises.mkdir(path.dirname(resolved), { recursive: true });
+    return fs.promises.writeFile(resolved, content, encoding);
+  }
+
+  static writeSync(filePath, content, encoding = 'utf8') {
+    const resolved = path.resolve(filePath);
+    fs.mkdirSync(path.dirname(resolved), { recursive: true });
+    return fs.writeFileSync(resolved, content, encoding);
+  }
+
+  static async writeJSON(filePath, obj, pretty = true) {
+    const content = pretty ? JSON.stringify(obj, null, 2) : JSON.stringify(obj);
+    return ThyFileLib.write(filePath, content);
+  }
+
+  static async append(filePath, content, encoding = 'utf8') {
+    const resolved = path.resolve(filePath);
+    await fs.promises.mkdir(path.dirname(resolved), { recursive: true });
+    return fs.promises.appendFile(resolved, content, encoding);
+  }
+
+  static async writeLines(filePath, lines, encoding = 'utf8') {
+    return ThyFileLib.write(filePath, lines.join('\n'), encoding);
+  }
+
+  // ─── File & Directory Management ───────────────────────────────────────────
+  static exists(filePath) {
+    return fs.existsSync(path.resolve(filePath));
+  }
+
+  static async delete(filePath) {
+    const resolved = path.resolve(filePath);
+    const stat = await fs.promises.stat(resolved);
+    if (stat.isDirectory()) {
+      return fs.promises.rm(resolved, { recursive: true, force: true });
+    }
+    return fs.promises.unlink(resolved);
+  }
+
+  static async mkdir(dirPath) {
+    return fs.promises.mkdir(path.resolve(dirPath), { recursive: true });
+  }
+
+  static async listDir(dirPath, recursive = false) {
+    const resolved = path.resolve(dirPath);
+    if (!recursive) {
+      return fs.promises.readdir(resolved);
+    }
+    const entries = await fs.promises.readdir(resolved, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+      const fullPath = path.join(resolved, entry.name);
+      if (entry.isDirectory()) {
+        const subFiles = await ThyFileLib.listDir(fullPath, true);
+        files.push(...subFiles);
+      } else {
+        files.push(fullPath);
+      }
+    }
+    return files;
+  }
+
+  static async copy(src, dst) {
+    const rSrc = path.resolve(src);
+    const rDst = path.resolve(dst);
+    await fs.promises.mkdir(path.dirname(rDst), { recursive: true });
+    return fs.promises.copyFile(rSrc, rDst);
+  }
+
+  static async move(src, dst) {
+    const rSrc = path.resolve(src);
+    const rDst = path.resolve(dst);
+    await fs.promises.mkdir(path.dirname(rDst), { recursive: true });
+    return fs.promises.rename(rSrc, rDst);
+  }
+
+  static async stat(filePath) {
+    const st = await fs.promises.stat(path.resolve(filePath));
+    return {
+      size: st.size,
+      isFile: st.isFile(),
+      isDirectory: st.isDirectory(),
+      created: st.birthtime,
+      modified: st.mtime,
+      accessed: st.atime,
+    };
+  }
+
+  static watch(filePath, callback) {
+    return fs.watch(path.resolve(filePath), callback);
+  }
+
+  // ─── Streams ───────────────────────────────────────────────────────────────
+  static readStream(filePath, options = {}) {
+    return fs.createReadStream(path.resolve(filePath), options);
+  }
+
+  static writeStream(filePath, options = {}) {
+    return fs.createWriteStream(path.resolve(filePath), options);
+  }
+
+  // ─── Compression ───────────────────────────────────────────────────────────
+  static async compress(srcPath, dstPath) {
+    const data = await fs.promises.readFile(path.resolve(srcPath));
+    const compressed = await gzip(data);
+    const target = dstPath || (srcPath + '.gz');
+    await fs.promises.writeFile(path.resolve(target), compressed);
+    return target;
+  }
+
+  static async decompress(srcPath, dstPath) {
+    const data = await fs.promises.readFile(path.resolve(srcPath));
+    const decompressed = await gunzip(data);
+    const target = dstPath || srcPath.replace(/\.gz$/, '');
+    await fs.promises.writeFile(path.resolve(target), decompressed);
+    return target;
+  }
+
+  // ─── Path Utilities ────────────────────────────────────────────────────────
+  static join(...parts) { return path.join(...parts); }
+  static resolve(...parts) { return path.resolve(...parts); }
+  static dirname(p) { return path.dirname(p); }
+  static basename(p, ext) { return path.basename(p, ext); }
+  static extname(p) { return path.extname(p); }
+}
+
+module.exports = ThyFileLib;