thyscript 1.0.0

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "thyscript",
+  "version": "1.0.0",
+  "description": "ThyScript - A blazing-fast programming language built on Node.js for ML, physics simulation, web, game engine, full-stack, and complex algorithms",
+  "main": "src/index.js",
+  "bin": {
+    "thy-node": "bin/thy-node.js",
+    "thy": "bin/thy.js",
+    "thys": "bin/thys.js"
+  },
+  "scripts": {
+    "test": "node tests/run-tests.js",
+    "build": "node scripts/build.js"
+  },
+  "keywords": [
+    "thyscript",
+    "programming-language",
+    "jit-compiler",
+    "machine-learning",
+    "physics-simulation",
+    "web",
+    "full-stack",
+    "game-engine"
+  ],
+  "author": "ThyScript Team",
+  "license": "MIT",
+  "dependencies": {
+    "acorn": "^8.11.3",
+    "bcryptjs": "^3.0.3",
+    "better-sqlite3": "^13.0.3",
+    "boxen": "^5.1.2",
+    "chalk": "^4.1.2",
+    "chokidar": "^3.5.3",
+    "commander": "^11.1.0",
+    "compression": "^1.7.4",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "fast-json-stringify": "^5.9.1",
+    "figlet": "^1.7.0",
+    "jsonwebtoken": "^9.0.2",
+    "mathjs": "^12.2.1",
+    "node-cache": "^5.1.2",
+    "ora": "^5.4.1",
+    "socket.io": "^4.6.1",
+    "toml": "^3.0.0",
+    "uuid": "^9.0.1",
+    "ws": "^8.16.0",
+    "yaml": "^2.3.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/scripts/_class.js

@@ -0,0 +1,18 @@
+'use strict';
+const Thy = require('../src/index.js');
+const src = `class A: end()
+const table a = new A()
+print(a instanceof A)
+`;
+(async () => {
+  try {
+    const lexer = new Thy.Lexer(src, '<t>');
+    const tokens = lexer.tokenize();
+    const parser = new Thy.Parser(tokens, src, '<t>');
+    const ast = parser.parse();
+    const c2 = new Thy.JITCompiler(ast, src, '<t>', {});
+    const compiled = c2.compile();
+    console.log('=== COMPILED ===');
+    console.log(compiled);
+  } catch (e) { console.log('ERR', e.message); } finally { process.exit(0); }
+})();

package/scripts/_class2.js

@@ -0,0 +1,11 @@
+'use strict';
+const Thy = require('../src/index.js');
+const src = `class A\nend()\nconst table a = new A()\n`;
+try {
+  const lexer = new Thy.Lexer(src, '<t>');
+  const tokens = lexer.tokenize();
+  console.log('tokens:', tokens.map(t=>t.type).join(','));
+  const parser = new Thy.Parser(tokens, src, '<t>');
+  const ast = parser.parse();
+  console.log('AST types:', (ast.body||ast.statements||[]).map(s=>s.type).join(','));
+} catch(e){ console.log('ERR', e.message); }

package/scripts/_class3.js

@@ -0,0 +1,21 @@
+'use strict';
+const Thy = require('../src/index.js');
+const src = `public class(A):\nend()\nconst table a = new A()\nprint(typeof a)\n`;
+(async () => {
+  try {
+    const lexer = new Thy.Lexer(src, '<t>');
+    const tokens = lexer.tokenize();
+    const parser = new Thy.Parser(tokens, src, '<t>');
+    const ast = parser.parse();
+    console.log('AST types:', (ast.body||ast.statements||[]).map(s=>s.type).join(','));
+    const c2 = new Thy.JITCompiler(ast, src, '<t>', {});
+    const compiled = c2.compile();
+    const hasClass = compiled.includes('class A') || compiled.includes('class A ');
+    console.log('has class A decl:', hasClass);
+    const runtime = new Thy.ThyRuntime({});
+    await runtime.init();
+    const ctx = runtime.buildContext();
+    await Promise.race([c2.execute(compiled, ctx), new Promise((_,rej)=>setTimeout(()=>rej(new Error('TIMEOUT')),3000))]);
+    console.log('EXEC OK');
+  } catch (e) { console.log('ERR', e.message, e.stack && e.stack.split('\n')[1]); } finally { process.exit(0); }
+})();

package/scripts/_dstruct.js

@@ -0,0 +1,20 @@
+'use strict';
+const Thy = require('../src/index.js');
+const src = `const table [a, b] = [1, 2, 3]
+print(a)
+print(b)
+`;
+console.log('--- lexing ---');
+try {
+  const lexer = new Thy.Lexer(src, '<t>');
+  const tokens = lexer.tokenize();
+  console.log('tokens:', tokens.map(t => t.type).join(','));
+} catch (e) { console.log('LEX ERRR', e.message); }
+console.log('--- parsing ---');
+try {
+  const lexer = new Thy.Lexer(src, '<t>');
+  const tokens = lexer.tokenize();
+  const parser = new Thy.Parser(tokens, src, '<t>');
+  const ast = parser.parse();
+  console.log('parsed OK');
+} catch (e) { console.log('PARSE ERR', e.message); }

package/scripts/_dstruct2.js

@@ -0,0 +1,24 @@
+'use strict';
+const Thy = require('../src/index.js');
+const src = `const table [a, b] = [1, 2, 3]
+print(a)
+print(b)
+`;
+(async () => {
+  try {
+    const lexer = new Thy.Lexer(src, '<t>');
+    const tokens = lexer.tokenize();
+    const parser = new Thy.Parser(tokens, src, '<t>');
+    const ast = parser.parse();
+    const c2 = new Thy.JITCompiler(ast, src, '<t>', {});
+    const compiled = c2.compile();
+    console.log('COMPILED:\n', compiled.split('\n').filter(l => l.includes('a')||l.includes('[')).slice(0,9).join('\n'));
+    const runtime = new Thy.ThyRuntime({});
+    await runtime.init();
+    const ctx = runtime.buildContext();
+    const r = await Promise.race([c2.execute(compiled, ctx), new Promise((_,rej)=>setTimeout(()=>rej(new Error('TIMEOUT')),3000))]);
+    console.log('EXEC OK', r);
+  } catch (e) {
+    console.log('ERR', e.message);
+  } finally { process.exit(0); }
+})();

package/scripts/_scaffold.js

@@ -0,0 +1,16 @@
+'use strict';
+const t = require('../src/index.js');
+const src = `program MyApp {
+  start {
+    print("Hello")
+    let x: int = 42
+    print(x)
+  }
+}
+`;
+try {
+  const js = t.compile(src, 't.thy', {});
+  console.log('scaffold COMPILES, bytes=', js.length);
+} catch (e) {
+  console.log('scaffold FAIL:', e.message);
+}

package/scripts/_scaffold2.js

@@ -0,0 +1,16 @@
+'use strict';
+const t = require('../src/index.js');
+const src = `program MyApp {
+  start {
+    print("HelloFromScaffold")
+    let x = 42
+    print(x)
+  }
+}
+`;
+try {
+  const js = t.compile(src, 't.thy', {});
+  const body = js.split('// ── program body')[1] || js;
+  console.log('BODY HAS print:', body.includes('print("HelloFromScaffold")'));
+  console.log('BODY snippet:', body.slice(0, 300));
+} catch (e) { console.log('FAIL', e.message); }

package/scripts/_scaffold3.js

@@ -0,0 +1,26 @@
+'use strict';
+const t = require('../src/index.js');
+const src = `program MyApp {
+  start {
+    print("HelloFromScaffold")
+    let x = 42
+    print(x)
+  }
+}
+`;
+(async () => {
+  try {
+    const js = t.compile(src, 't.thy', {});
+    const runtime = new t.ThyRuntime({});
+    await runtime.init();
+    const lexer = new t.Lexer(src, 't.thy');
+    const tokens = lexer.tokenize();
+    const parser = new t.Parser(tokens, src, 't.thy');
+    const ast = parser.parse();
+    const c2 = new t.JITCompiler(ast, src, 't.thy', {});
+    const compiled = c2.compile();
+    const ctx = runtime.buildContext();
+    await Promise.race([c2.execute(compiled, ctx), new Promise((_, r) => setTimeout(() => r(new Error('TIMEOUT')), 3000))]);
+    console.log('EXEC OK');
+  } catch (e) { console.log('ERR', e.message); } finally { process.exit(0); }
+})();

package/scripts/_tpl_compile.js

@@ -0,0 +1,13 @@
+const Thy = require('../src/index.js');
+const src = `const table a = "Hello"
+const table b = "World"
+print(\`Template ${'$'}{a}-${'$'}{b}\`)
+`;
+try {
+  const js = Thy.compile(src, 'tpl.thy', {});
+  // Find the template literal line
+  const lines = js.split('\n');
+  lines.forEach((l, i) => { if (l.includes('`')) console.log('LINE', i, JSON.stringify(l)); });
+} catch (e) {
+  console.log('COMPILE ERR:', e.message);
+}

package/scripts/_tpl_test.js

@@ -0,0 +1,9 @@
+const L = require('../src/lexer/Lexer');
+const src = `const table a = "Hello"
+const table b = "World"
+print(\`Template ${'$'}{a}-${'$'}{b}\`)
+print(\`val=${'$'}{1+2}\`)
+`;
+const l = new L(src);
+const toks = l.tokenize();
+console.log(JSON.stringify(toks.filter(t => t.type === 'TEMPLATE_LITERAL'), null, 2));

package/scripts/_typeof.js

@@ -0,0 +1,26 @@
+'use strict';
+const Thy = require('../src/index.js');
+const src = `const table x = 5
+print(typeof x)
+class A: end()
+const table a = new A()
+print(a instanceof A)
+`;
+(async () => {
+  try {
+    const lexer = new Thy.Lexer(src, '<t>');
+    const tokens = lexer.tokenize();
+    const parser = new Thy.Parser(tokens, src, '<t>');
+    const ast = parser.parse();
+    const c2 = new Thy.JITCompiler(ast, src, '<t>', {});
+    const compiled = c2.compile();
+    console.log('COMPILED tail:\n' + compiled.split('\n').slice(-25).join('\n'));
+    const runtime = new Thy.ThyRuntime({});
+    await runtime.init();
+    const ctx = runtime.buildContext();
+    const r = await Promise.race([c2.execute(compiled, ctx), new Promise((_, rej) => setTimeout(() => rej(new Error('TIMEOUT')), 3000))]);
+    console.log('EXEC OK', r);
+  } catch (e) {
+    console.log('ERR', e.message, '\n', e.stack && e.stack.split('\n').slice(0,3).join('\n'));
+  } finally { process.exit(0); }
+})();

package/scripts/_typeof2.js

@@ -0,0 +1,25 @@
+'use strict';
+const Thy = require('../src/index.js');
+const src = `const table x = 5
+print(typeof x)
+public class A:
+end()
+const table a = new A()
+print(a instanceof A)
+`;
+(async () => {
+  try {
+    const lexer = new Thy.Lexer(src, '<t>');
+    const tokens = lexer.tokenize();
+    const parser = new Thy.Parser(tokens, src, '<t>');
+    const ast = parser.parse();
+    const c2 = new Thy.JITCompiler(ast, src, '<t>', {});
+    const compiled = c2.compile();
+    console.log('has class:', compiled.includes('class A'));
+    const runtime = new Thy.ThyRuntime({});
+    await runtime.init();
+    const ctx = runtime.buildContext();
+    const r = await Promise.race([c2.execute(compiled, ctx), new Promise((_, rej) => setTimeout(() => rej(new Error('TIMEOUT')), 3000))]);
+    console.log('EXEC OK');
+  } catch (e) { console.log('ERR', e.message); } finally { process.exit(0); }
+})();

package/scripts/patch_genmethod.js

@@ -0,0 +1,44 @@
+const fs = require('fs');
+let code = fs.readFileSync('src/compiler/CodeGenerator.js', 'utf8');
+
+// Find the old block by index
+const marker = 'if (!isStatic && classProps.length > 0) {';
+const markerIdx = code.indexOf(marker);
+if (markerIdx === -1) {
+  console.error('Marker not found!');
+  process.exit(1);
+}
+
+// Find end of the whole _genMethod closing brace after marker
+const blockEnd = code.indexOf('\n  }\n\n  // ─── HTML class', markerIdx);
+if (blockEnd === -1) {
+  console.error('End marker not found!');
+  process.exit(1);
+}
+
+const before = code.slice(0, markerIdx);
+const after = code.slice(blockEnd); // includes '\n  }\n\n  // ─── HTML class...'
+
+const newBlock = `if (!isStatic && classProps.length > 0) {
+      // Destructure class props as mutable lets (allows += inside methods)
+      this._emit('let { ' + classProps.join(', ') + ' } = this;');
+      this._genBlockOrList(method.body);
+      // Write any mutations back to the instance
+      this._emit('Object.assign(this, { ' + classProps.join(', ') + ' });');
+    } else {
+      this._genBlockOrList(method.body);
+    }
+    this._pop();
+    this._emit('}');
+  }`;
+
+const newCode = before + newBlock + after;
+fs.writeFileSync('src/compiler/CodeGenerator.js', newCode);
+
+// Verify
+const verify = fs.readFileSync('src/compiler/CodeGenerator.js', 'utf8');
+if (verify.includes('Destructure class props as mutable lets')) {
+  console.log('SUCCESS: _genMethod patched correctly!');
+} else {
+  console.error('FAIL: patch not applied');
+}

package/scripts/smoke_test.js

@@ -0,0 +1,167 @@
+'use strict';
+/**
+ * Smoke test harness - exercises many ThyScript language features
+ * to uncover crashes, undefined behavior, and anomalies.
+ */
+const Thy = require('../src/index.js');
+
+const cases = {
+  'basic-assign': `
+const table x = 10
+print(x)
+const table y = x + 5 * 2
+print(y)
+`,
+  'string-concat': `
+const table a = "Hello"
+const table b = "World"
+print(a + " " + b)
+print(\`Template ${'$'}{a}-${'$'}{b}\`)
+`,
+  'if-elif-else': `
+const table v = 42
+if(v < 10):
+  print("small")
+elif(v < 50):
+  print("medium")
+else:
+  print("large")
+end()
+`,
+  'while-loop': `
+const table i = 0
+const table s = 0
+while(i < 10):
+  add i in s
+  add 1 in i
+end()
+print(s)
+`,
+  'for-loop': `
+const table arr = [1, 2, 3, 4]
+const table out = 0
+for item in arr:
+  add item in out
+end()
+print(out)
+`,
+  'functions': `
+func square(x):
+  return calculate(x * x)
+end()
+print(square(5))
+`,
+  'object-literal': `
+const table obj = {name: "Budi", age: 25}
+print(obj.name)
+print(obj["name"])
+`,
+  'prime-check': `
+func isPrime(n):
+  if(n <= 1):
+    return false
+  end()
+  const table i = 2
+  while(i * i <= n):
+    if(n % i == 0):
+      return false
+    end()
+    add 1 in i
+  end()
+  return true
+end()
+print(isPrime(7))
+print(isPrime(10))
+`,
+  'switch': `
+const table day = 2
+switch(day):
+  case 1:
+    print("Monday")
+  case 2:
+    print("Tuesday")
+  default:
+    print("Other")
+end()
+`,
+  'try-catch': `
+try:
+  const table z = 10 / 0
+  print("no error")
+except e:
+  print("caught: " + e)
+end()
+`,
+  'ternary': `
+const table age = 17
+print(age >= 18 ? "adult" : "minor")
+`,
+  'string-methods': `
+const table s = "  Hello World  "
+print(string.trim(s).length)
+print(string.upper(s))
+`,
+  'array-methods': `
+const table nums = [3, 1, 2]
+print(array.sort(nums).join(","))
+`,
+  'nested-loop': `
+const table total = 0
+const table i = 0
+while(i < 3):
+  const table j = 0
+  while(j < 3):
+    add (i * j) in total
+    add 1 in j
+  end()
+  add 1 in i
+end()
+print(total)
+`,
+  'class-basic': `
+public class Animal:
+  public name = "unknown"
+  public func speak():
+    return "..." + this.name
+  end()
+  public func setName(n):
+    change(this.name to(n))
+  end()
+end()
+const table a = new Animal()
+a.setName("Kucing")
+print(a.speak())
+`,
+};
+
+async function main() {
+  let pass = 0, fail = 0;
+  for (const [name, src] of Object.entries(cases)) {
+    try {
+      // Compile
+      const js = Thy.compile(src, `<${name}>`, {});
+      // Execute
+      const runtime = new Thy.ThyRuntime({ enableClustering: false });
+      await runtime.init();
+      const context = runtime.buildContext();
+      const compiler = new Thy.JITCompiler(Thy.astFromSource ? null : null, src);
+      // Recompile via runSource-like path
+      const lexer = new Thy.Lexer(src, `<${name}>`);
+      const tokens = lexer.tokenize();
+      const parser = new Thy.Parser(tokens, src, `<${name}>`);
+      const ast = parser.parse();
+      const c2 = new Thy.JITCompiler(ast, src, `<${name}>`, {});
+      const compiled = c2.compile();
+      await c2.execute(compiled, context);
+      console.log(`PASS  ${name}`);
+      pass++;
+    } catch (e) {
+      console.log(`FAIL  ${name}: ${e.message}`);
+      fail++;
+    }
+  }
+  console.log(`\n=== Smoke: ${pass} passed, ${fail} failed ===`);
+  process.exit(fail ? 1 : 0);
+}
+
+main().catch(e => { console.error('FATAL', e); process.exit(1); });

package/scripts/smoke_test2.js

@@ -0,0 +1,151 @@
+'use strict';
+const Thy = require('../src/index.js');
+
+const cases = {
+  'class-inheritance': `
+public class Animal:
+  public name = "?"
+  public func speak():
+    return "sound"
+  end()
+  public func setName(n):
+    change(this.name to(n))
+  end()
+end()
+public class Dog extends Animal:
+  public func speak():
+    return "Woof"
+  end()
+end()
+const table d = new Dog()
+d.setName("Rex")
+print(d.name)
+print(d.speak())
+`,
+  'class-inheritance-super': `
+public class Base:
+  public value = 10
+  public func get():
+    return this.value
+  end()
+end()
+public class Child extends Base:
+  public func get():
+    return this.value * 2
+  end()
+end()
+const table c = new Child()
+print(c.get())
+`,
+  'async-func': `
+async func fetchVal():
+  return 42
+end()
+print(fetchVal())
+`,
+  'destructure-array': `
+const table [a, b] = [1, 2, 3]
+print(a)
+print(b)
+`,
+  'destructure-object': `
+const table {x, y} = {x: 5, y: 7}
+print(x)
+print(y)
+`,
+  'spread': `
+const table a = [1, 2]
+const table b = [...a, 3, 4]
+print(b.length)
+print(b.join(','))
+`,
+  'nested-object-access': `
+const table user = {profile: {name: "Budi", address: {city: "Jakarta"}}}
+print(user.profile.address.city)
+print(user.profile["name"])
+`,
+  'js-array-methods': `
+const table nums = [5, 3, 8, 1]
+print(nums.sort((a,b) => a-b).join(','))
+print(nums.map(x => x * 2).join(','))
+print(nums.filter(x => x > 3).join(','))
+`,
+  'string-template-nested': `
+const table name = "World"
+const table greeting = \`Hello ${'$'}{name}, sum=${'$'}{1+2}\`
+print(greeting)
+`,
+  'modulo-power': `
+print(calculate(5 ** 2))
+print(calculate(10 % 3))
+print(calculate(2 ** 3 ** 2))
+`,
+  'object-in-array': `
+const table items = [{id: 1, name: "A"}, {id: 2, name: "B"}]
+print(items.length)
+print(items[1].name)
+`,
+  'whilenested-if': `
+const table out = 0
+const table i = 0
+while(i < 10):
+  if(i % 2 == 0):
+    add i in out
+  end()
+  add 1 in i
+end()
+print(out)
+`,
+  'null-coalesce': `
+const table a = null
+const table b = a ?? "default"
+print(b)
+`,
+  'typeof-instanceof': `
+const table x = 5
+print(typeof x)
+public class(A):
+end()
+const table a = new A()
+print(a instanceof A)
+`,
+  'string-escape': `
+print("line1\\nline2")
+print("tab\\there")
+print("quote\\" and \\'")
+`,
+};
+
+async function main() {
+  let pass = 0, fail = 0;
+  // Prevent compiled programs' .catch(process.exit) from killing the harness
+  const origExit = process.exit;
+  process.exit = () => { throw new Error('process.exit called by user program'); };
+  try {
+    for (const [name, src] of Object.entries(cases)) {
+      try {
+        const runtime = new Thy.ThyRuntime({ enableClustering: false });
+        await runtime.init();
+        const lexer = new Thy.Lexer(src, `<${name}>`);
+        const tokens = lexer.tokenize();
+        const parser = new Thy.Parser(tokens, src, `<${name}>`);
+        const ast = parser.parse();
+        const c2 = new Thy.JITCompiler(ast, src, `<${name}>`, {});
+        const compiled = c2.compile();
+        const context = runtime.buildContext();
+        await c2.execute(compiled, context);
+        console.log(`PASS  ${name}`);
+        pass++;
+      } catch (e) {
+        console.log(`FAIL  ${name}: ${e.message}`);
+        fail++;
+      }
+    }
+  } finally {
+    process.exit = origExit;
+  }
+  console.log(`\n=== Extended Smoke: ${pass} passed, ${fail} failed ===`);
+  process.exit(fail ? 1 : 0);
+}
+
+main().catch(e => { console.error('FATAL', e); process.exit(1); });