cajyu 1.0.1 → 1.2.0

package/README.md

@@ -1,5 +1,9 @@
 # Cajyu
 
+<p align="center">
+  <img src="https://raw.githubusercontent.com/abs-js/Cajyu/main/logos/logo-128.png" alt="Cajyu Logo" width="128">
+</p>
+
 **A clean, practical programming language that transpiles to JavaScript.**
 
 Cajyu gives you a simpler, more expressive syntax while staying fully compatible with the JavaScript ecosystem.
@@ -15,7 +19,8 @@ Cajyu gives you a simpler, more expressive syntax while staying fully compatible
 - Clean syntax for variables, functions, classes, loops and conditionals
 - Transpiles to modern JavaScript
 - Real HTTP server with POST handlers, sleep/wake
-- Official libraries: `serial`, `fs`, `math`, `http`, `websocket`
+- WebSocket that automatically sends and receives JSON
+- Official libraries: `serial`, `fs`, `math`, `http`, `websocket`, `string`, `json`, `exec`, `fetch`
 - Optional runtime typing
 - Async with `sync fn` and `wait`
 - One-liners and stacking
@@ -121,16 +126,24 @@ server.post(fn b {
 })
 ```
 
-### WebSocket
+### WebSocket (JSON)
 ```cajyu
 import WS from CajyuLibs.websocket
 
 var wss = new WS.Server(8080)
-wss.on("connection", fn client {
-  print("client connected")
-})
 wss.on("message", fn msg, client {
-  wss.broadcast(msg)
+  wss.broadcast({ echo: msg })
+})
+```
+
+### Exec & Fetch
+```cajyu
+import exec from CajyuLibs.exec
+var files = exec.exec("ls -a")
+
+import fetch from CajyuLibs.fetch
+fetch.fetch("https://api.github.com", {}, null, fn result, ms {
+  print(result)
 })
 ```
 
@@ -146,6 +159,10 @@ cajyu inst fs
 cajyu inst math
 cajyu inst http
 cajyu inst websocket
+cajyu inst string
+cajyu inst json
+cajyu inst exec
+cajyu inst fetch
 ```
 
 ---

package/bin/cajyu.js

@@ -9,7 +9,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 const CAJYULIBS_REPO = 'https://github.com/abs-js/CajyuLibs.git';
-const VERSION = '1.1.0';
+const VERSION = '1.2.0';
 
 const args = process.argv.slice(2);
 const command = args[0];

package/logos/README.md

@@ -0,0 +1,8 @@
+# Cajyu Logos
+
+Square logo versions:
+- logo-64.png (64x64)
+- logo-128.png (128x128)
+- logo-256.png (256x256)
+
+Yellow ink splash with brown Y-shaped stem on black background.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cajyu",
-  "version": "1.0.01",
+  "version": "1.2.0",
   "description": "Cajyu programming language - a custom language that compiles to JavaScript",
   "main": "src/compiler.js",
   "bin": {

package/src/compiler-ast-note.md

@@ -0,0 +1,16 @@
+# AST Migration in progress
+
+The compiler now has a real Tokenizer + recursive descent Parser that builds an AST.
+
+Current status:
+- Tokenizer handles strings, numbers, identifiers, keywords correctly
+- Parser builds AST for var, fn, if/elif/else, while, for, class, return, expressions
+- Code generator emits JavaScript from the AST
+
+Still being completed:
+- Full import resolution
+- Builtins (range, typeCheck)
+- Async (sync/wait)
+- One-liners and more edge cases
+
+This is the foundation for a robust parser.

package/src/compiler.js

@@ -2,23 +2,64 @@ import fs from 'fs';
 import path from 'path';
 import { pathToFileURL } from 'url';
 
+// Error codes
+const ERRORS = {
+  ERR001: 'Syntax error',
+  ERR002: 'Unexpected token',
+  ERR003: 'Missing closing brace',
+  ERR004: 'Type mismatch',
+  ERR005: 'Undefined variable',
+  ERR006: 'Invalid function call',
+  ERR007: 'Missing parentheses',
+  ERR008: 'Invalid import',
+  ERR009: 'Unexpected end of file',
+  ERR010: 'Invalid operator',
+  ERR011: 'Missing semicolon or block',
+  ERR012: 'Invalid type annotation',
+  ERR013: 'Keyword used as identifier',
+  ERR014: 'Unterminated string',
+  ERR015: 'Invalid number',
+  ERR016: 'Duplicate declaration',
+  ERR017: 'Missing return value',
+  ERR018: 'Invalid class member',
+  ERR019: 'Async error',
+  ERR020: 'Library not found'
+};
+
+class CajyuError extends Error {
+  constructor(code, line, column, lineContent, message) {
+    const errName = ERRORS[code] || 'Unknown error';
+    const pointer = ' '.repeat(Math.max(0, column)) + '^';
+    super(`There is an ${errName.toLowerCase()} in line ${line}: ${code}.\n    ${lineContent.trim()}\n   ${pointer}`);
+    this.code = code;
+    this.line = line;
+    this.column = column;
+  }
+}
+
 export async function compileAndRun(filePath) {
   if (!fs.existsSync(filePath)) {
-    console.error(`Arquivo não encontrado: ${filePath}`);
+    console.error(`File not found: ${filePath}`);
     process.exit(1);
   }
   const source = fs.readFileSync(filePath, 'utf-8');
-  const jsCode = transpile(source, path.dirname(filePath));
-  const tempFile = path.join('/tmp', `cajyu_${Date.now()}.mjs`);
-  fs.writeFileSync(tempFile, jsCode);
   try {
-    await import(pathToFileURL(tempFile).href);
-    console.log('--- Execução Cajyu ---');
+    const jsCode = transpile(source, path.dirname(filePath));
+    const tempFile = path.join('/tmp', `cajyu_${Date.now()}.mjs`);
+    fs.writeFileSync(tempFile, jsCode);
+    try {
+      await import(pathToFileURL(tempFile).href);
+      console.log('--- Cajyu execution ---');
+    } finally {
+      try { fs.unlinkSync(tempFile); } catch {}
+    }
   } catch (err) {
-    console.error('Erro na execução:', err.message);
-    console.error(err.stack);
-  } finally {
-    try { fs.unlinkSync(tempFile); } catch {}
+    if (err instanceof CajyuError) {
+      console.error(err.message);
+    } else {
+      console.error('Runtime error:', err.message);
+    }
+    process.exit(1);
   }
 }
 
@@ -26,13 +67,21 @@ function transpile(source, baseDir) {
   const lines = source.split('\n');
   const imports = [];
   const codeLines = [];
-  for (const line of lines) {
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
     const m = line.match(/^\s*import\s+(\*|\w+)\s+from\s+['"]?([^\s'"]+)['"]?\s*;?\s*$/);
-    if (m) imports.push({ what: m[1], from: m[2] });
-    else codeLines.push(line);
+    if (m) {
+      imports.push({ what: m[1], from: m[2], line: i + 1 });
+    } else {
+      codeLines.push(line);
+    }
   }
+
   let code = codeLines.join('\n');
 
+  code = preprocessWithErrors(code, lines);
+
   let importCode = '';
   for (const imp of imports) {
     const libPath = resolveLib(imp.from, baseDir);
@@ -43,10 +92,11 @@ function transpile(source, baseDir) {
       } else {
         importCode += `const { CayjuLib: _lib${imp.what} } = await import('${url}'); const ${imp.what} = _lib${imp.what}.${imp.what} || _lib${imp.what};\n`;
       }
+    } else {
+      throw new CajyuError('ERR020', imp.line, 0, lines[imp.line - 1] || '', `Library not found: ${imp.from}`);
     }
   }
 
-  code = preprocessKeywords(code);
   code = transpileFunctions(code);
   code = transpileAnonymousFunctions(code);
   code = transpileControlFlow(code);
@@ -63,24 +113,95 @@ function _range(a, b, c) {
 function _typeCheck(val, type) {
   if (!type) return val;
   const t = String(type).toLowerCase();
-  if (t === 'string' && typeof val !== 'string') throw new Error('esperado String');
-  if ((t === 'number' || t === 'int' || t === 'float') && typeof val !== 'number') throw new Error('esperado Number');
-  if (t === 'boolean' && typeof val !== 'boolean') throw new Error('esperado Boolean');
-  if (t === 'array' && !Array.isArray(val)) throw new Error('esperado Array');
+  if (t === 'string' && typeof val !== 'string') throw new Error('ERR004: expected String');
+  if ((t === 'number' || t === 'int' || t === 'float') && typeof val !== 'number') throw new Error('ERR004: expected Number');
+  if (t === 'boolean' && typeof val !== 'boolean') throw new Error('ERR004: expected Boolean');
+  if (t === 'array' && !Array.isArray(val)) throw new Error('ERR004: expected Array');
+  if (t === 'object' && (typeof val !== 'object' || val === null)) throw new Error('ERR004: expected Object');
   return val;
 }
 `;
 
-  const final = `
+  return `
 ${importCode}
 ${builtins}
 (async () => {
 ${code}
-})().catch(console.error);
+})().catch(e => { console.error(e.message); process.exit(1); });
 `;
+}
+
+function preprocessWithErrors(code, originalLines) {
+  const result = [];
+  const lines = code.split('\n');
+
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    let newLine = '';
+    let inString = false;
+    let stringChar = '';
 
-  fs.writeFileSync('/tmp/cajyu_debug.mjs', final);
-  return final;
+    for (let j = 0; j < line.length; j++) {
+      const ch = line[j];
+
+      if (!inString && (ch === '"' || ch === "'")) {
+        inString = true;
+        stringChar = ch;
+        newLine += ch;
+        continue;
+      }
+      if (inString && ch === stringChar && line[j - 1] !== '\\') {
+        inString = false;
+        newLine += ch;
+        continue;
+      }
+      if (inString) {
+        newLine += ch;
+        continue;
+      }
+
+      if (line.substr(j, 3) === 'and' && isWordBoundary(line, j, 3)) {
+        newLine += '&&';
+        j += 2;
+        continue;
+      }
+      if (line.substr(j, 2) === 'or' && isWordBoundary(line, j, 2)) {
+        newLine += '||';
+        j += 1;
+        continue;
+      }
+      if (line.substr(j, 3) === 'not' && isWordBoundary(line, j, 3)) {
+        newLine += '!';
+        j += 2;
+        continue;
+      }
+
+      newLine += ch;
+    }
+
+    if (inString) {
+      throw new CajyuError('ERR014', i + 1, line.length, line, 'Unterminated string');
+    }
+
+    newLine = newLine
+      .replace(/sync\s+fn\s+(\w+)/g, 'async function $1')
+      .replace(/\bwait\s+/g, 'await ')
+      .replace(/\belif\b/g, 'else if')
+      .replace(/\bSelf\./g, 'this.')
+      .replace(/\brange\(/g, '_range(')
+      .replace(/var\s+(\w+):(\w+)\s*=\s*(.+)/g, 'let $1 = _typeCheck($3, "$2")')
+      .replace(/var\s+(\w+)\s*=/g, 'let $1 =');
+
+    result.push(newLine);
+  }
+
+  return result.join('\n');
+}
+
+function isWordBoundary(line, index, len) {
+  const before = index === 0 || !/\w/.test(line[index - 1]);
+  const after = index + len >= line.length || !/\w/.test(line[index + len]);
+  return before && after;
 }
 
 function resolveLib(from, baseDir) {
@@ -100,21 +221,6 @@ function cleanParams(s) {
   return (s || '').trim().split(',').map(p => p.trim().split(':')[0].trim()).filter(Boolean).join(', ');
 }
 
-function preprocessKeywords(code) {
-  return code
-    .replace(/\band\b/g, '&&')
-    .replace(/\bor\b/g, '||')
-    .replace(/\bnot\b/g, '!')
-    .replace(/sync\s+fn\s+(\w+)/g, 'async function $1')
-    .replace(/\bwait\s+/g, 'await ')
-    .replace(/\belif\b/g, 'else if')
-    .replace(/\bSelf\./g, 'this.')
-    .replace(/\brange\(/g, '_range(')
-    .replace(/\/\/\s*private\s+(\w+)/g, '/* private $1 */')
-    .replace(/var\s+(\w+):(\w+)\s*=\s*(.+)/g, 'let $1 = _typeCheck($3, "$2")')
-    .replace(/var\s+(\w+)\s*=/g, 'let $1 =');
-}
-
 function transpileFunctions(code) {
   return code
     .replace(/^fn\s+(\w+)\s+([^{]*)\{/gm, (_, n, p) => `function ${n}(${cleanParams(p)}) {`)
@@ -145,5 +251,7 @@ function transpileControlFlow(code) {
 function transpileOneLiners(code) {
   return code
     .replace(/return\s+(\{[^}]*\}|.+?)\s+if\s+([^;]+);/g, 'if ($2) return $1;')
-    .replace(/if\s+([^:{;\n]+)\s+return\s+([^;\n{]+)/g, 'if ($1) return $2;');
+    .replace(/if\s+([^:{;\n]+)\s+return\s+([^;\n{]+)/g, 'if ($1) return $2;')
+    .replace(/while\s+([^:{;\n]+)\s+([^;\n{]+);?/g, 'while ($1) { $2; }')
+    .replace(/for\s+(\w+)\s+in\s+([^ {\n;]+)\s+([^;\n{]+);?/g, 'for (let $1 of $2) { $3; }');
 }