cajyu 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,197 @@
-# Temporary Holding Version
+# Cajyu
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**A clean, practical programming language that transpiles to JavaScript.**
+
+Cajyu is designed for people who want a simpler syntax without leaving the JavaScript ecosystem. Write expressive code, get real JavaScript output, and use a growing set of official libraries.
+
+[![npm](https://img.shields.io/badge/npm-cajyu-blue)](https://www.npmjs.com/package/cajyu)
+[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+
+---
+
+## Features
+
+- **Familiar yet cleaner syntax** — variables, functions, classes, control flow, and loops that feel natural
+- **Transpiles to modern JavaScript** — runs anywhere Node.js runs
+- **Real HTTP server** — built-in `Server` class with POST handlers, sleep/wake, and static files
+- **Official libraries** — `serial`, `fs`, `math`, `http` (and more coming)
+- **Optional typing** — runtime type checks with `var x:Number = 10`
+- **Async support** — `sync fn` and `wait`
+- **One-liners & stacking** — concise style when you want it
+- **CLI** — `cajyu init`, `cajyu inst`, `cajyu run`
+
+---
+
+## Quick Start
+
+```bash
+# Install the CLI (once published)
+npm install -g cajyu
+
+# Or run directly from this repo
+node bin/cajyu.js --help
+```
+
+Create a new project:
+
+```bash
+cajyu init
+```
+
+Run a file:
+
+```bash
+cajyu run examples/fatorial.cjy
+```
+
+---
+
+## Syntax Overview
+
+### Variables
+```cajyu
+var name = "Cajyu"
+var age:Number = 17
+var items = [1, 2, 3]
+```
+
+### Functions
+```cajyu
+fn add a, b {
+  return a + b
+}
+
+fn double x {
+  return x * 2
+}
+```
+
+### Control Flow
+```cajyu
+if x > 10 {
+  print("big")
+} elif x > 5 {
+  print("medium")
+} else {
+  print("small")
+}
+```
+
+### Loops
+```cajyu
+for i in range(10) {
+  print(i)
+}
+
+while x < 100 {
+  x = x * 2
+}
+```
+
+### Classes
+```cajyu
+class Person {
+  Main name, age {
+    Self.name = name
+    Self.age = age
+  }
+  greet {
+    return "Hello, I'm " + Self.name
+  }
+}
+
+var p = new Person("Ana", 17)
+print(p.greet())
+```
+
+### Async
+```cajyu
+sync fn fetchData {
+  wait someAsyncCall()
+  return result
+}
+```
+
+### HTTP Server
+```cajyu
+import Server from CajyuLibs.http
+import print from CajyuLibs.serial
+
+var server = new Server(3000)
+
+server.post(fn b {
+  if !b.a and !b.b {
+    return { code: 400 }
+  }
+  return {
+    code: 200,
+    result: b.a + b.b
+  }
+})
+```
+
+---
+
+## Libraries
+
+Official libraries live in the [CajyuLibs](https://github.com/abs-js/CajyuLibs) repository.
+
+Install a library:
+
+```bash
+cajyu inst serial
+cajyu inst http
+```
+
+Import in your code:
+
+```cajyu
+import print from CajyuLibs.serial
+import Server from CajyuLibs.http
+```
+
+---
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `cajyu init` | Create a new project (`package.json` + structure) |
+| `cajyu inst <name>` | Install a library from CajyuLibs |
+| `cajyu run <file.cjy>` | Compile and run a Cajyu file |
+
+---
+
+## Project Structure
+
+```
+Cajyu/
+├── bin/cajyu.js          # CLI entry point
+├── src/compiler.js       # Transpiler
+├── examples/             # Working examples
+│   ├── fatorial.cjy
+│   ├── classe.cjy
+│   └── servidor-post.cjy
+└── package.json
+```
+
+---
+
+## Contributing
+
+Cajyu is early but intentional. Pull requests are welcome — especially for:
+
+- A proper parser (currently regex-based)
+- More language features
+- New official libraries
+- Better error messages
+
+---
+
+## License
+
+MIT
+
+---
+
+**Built for people who like clean code and real results.**

package/examples/classe.cjy

@@ -0,0 +1,16 @@
+import print from CajyuLibs.serial
+
+class Pessoa {
+  Main nome, idade {
+    Self.nome = nome
+    Self.idade = idade
+  }
+  // private nome
+  // private idade
+  apresentar {
+    return "Oi, eu sou " + Self.nome + " e tenho " + Self.idade + " anos"
+  }
+}
+
+var p = new Pessoa("Ana", 17)
+print(p.apresentar())

package/examples/fatorial.cjy

@@ -0,0 +1,13 @@
+import print from CajyuLibs.serial
+
+fn fac a {
+	if a <= 1 {
+		return 1
+	} else {
+		return a * fac(a - 1)
+	}
+}
+
+for i in range(10) {
+	print(fac(i));
+}

package/examples/servidor-post.cjy

@@ -0,0 +1,18 @@
+import Server from CajyuLibs.http
+import print from CajyuLibs.serial
+
+var server = new Server(3000)
+print("Servidor Cajyu pronto na porta 3000")
+
+server.post(fn b {
+  if !b.a and !b.b {
+    return { code: 400 }
+  }
+  return {
+    code: 200,
+    result: b.a + b.b
+  }
+})
+
+print("POST / com JSON {a, b} para somar")
+print("server.sleep() e server.wake() disponíveis")

package/package.json

@@ -1,6 +1,17 @@
 {
   "name": "cajyu",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Cajyu programming language - a custom language that compiles to JavaScript",
+  "main": "src/compiler.js",
+  "bin": {
+    "cajyu": "./bin/cajyu.js"
+  },
+  "scripts": {
+    "start": "node bin/cajyu.js"
+  },
+  "keywords": ["cajyu", "compiler", "language", "javascript"],
+  "author": "Cajyu Team",
+  "license": "MIT",
+  "dependencies": {},
+  "type": "module"
+}

package/src/compiler.js

@@ -0,0 +1,149 @@
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+
+export async function compileAndRun(filePath) {
+  if (!fs.existsSync(filePath)) {
+    console.error(`Arquivo não encontrado: ${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 ---');
+  } catch (err) {
+    console.error('Erro na execução:', err.message);
+    console.error(err.stack);
+  } finally {
+    try { fs.unlinkSync(tempFile); } catch {}
+  }
+}
+
+function transpile(source, baseDir) {
+  const lines = source.split('\n');
+  const imports = [];
+  const codeLines = [];
+  for (const line of lines) {
+    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);
+  }
+  let code = codeLines.join('\n');
+
+  let importCode = '';
+  for (const imp of imports) {
+    const libPath = resolveLib(imp.from, baseDir);
+    if (libPath && fs.existsSync(libPath)) {
+      const url = pathToFileURL(libPath).href;
+      if (imp.what === '*') {
+        importCode += `const _lib = await import('${url}'); Object.assign(globalThis, _lib.CayjuLib || _lib);\n`;
+      } else {
+        importCode += `const { CayjuLib: _lib${imp.what} } = await import('${url}'); const ${imp.what} = _lib${imp.what}.${imp.what} || _lib${imp.what};\n`;
+      }
+    }
+  }
+
+  code = preprocessKeywords(code);
+  code = transpileFunctions(code);
+  code = transpileAnonymousFunctions(code);
+  code = transpileControlFlow(code);
+  code = transpileOneLiners(code);
+
+  const builtins = `
+function _range(a, b, c) {
+  const r = [];
+  if (b == null) for (let i = 1; i <= a; i++) r.push(i);
+  else if (c == null) for (let i = a; i <= b; i++) r.push(i);
+  else for (let i = a; i <= b; i += c) r.push(i);
+  return r;
+}
+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');
+  return val;
+}
+`;
+
+  const final = `
+${importCode}
+${builtins}
+(async () => {
+${code}
+})().catch(console.error);
+`;
+
+  fs.writeFileSync('/tmp/cajyu_debug.mjs', final);
+  return final;
+}
+
+function resolveLib(from, baseDir) {
+  if (from.startsWith('CajyuLibs')) {
+    const name = from.split('.')[1] || 'serial';
+    const cands = [
+      path.resolve(baseDir, 'CajyuLibs', name, 'main.js'),
+      path.resolve(baseDir, '..', 'CajyuLibs', name, 'main.js'),
+      path.resolve(process.cwd(), 'CajyuLibs', name, 'main.js'),
+    ];
+    return cands.find(p => fs.existsSync(p));
+  }
+  return path.resolve(baseDir, from);
+}
+
+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)}) {`)
+    .replace(/^fn\s+(\w+)\s*\{/gm, 'function $1() {')
+    .replace(/Main\s+([^{]*)\{/g, (_, p) => `constructor(${cleanParams(p)}) {`)
+    .replace(/^\s*(\w+)\s*\{/gm, (m, name) => {
+      const keywords = ['if','else','while','for','return','class','fn','function','constructor'];
+      if (keywords.includes(name)) return m;
+      return `  ${name}() {`;
+    });
+}
+
+function transpileAnonymousFunctions(code) {
+  return code.replace(/(?<!^|\n)fn\s+([^{]*)\{/g, (_, params) => {
+    const p = cleanParams(params);
+    return `function(${p}) {`;
+  });
+}
+
+function transpileControlFlow(code) {
+  return code
+    .replace(/if\s+([^{]+?)\s*\{/g, 'if ($1) {')
+    .replace(/else\s+if\s+([^{]+?)\s*\{/g, 'else if ($1) {')
+    .replace(/while\s+([^{]+?)\s*\{/g, 'while ($1) {')
+    .replace(/for\s+(\w+)\s+in\s+([^ {\n]+)(\s*\{)/g, 'for (let $1 of $2) $3');
+}
+
+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;');
+}