cajyu 0.0.0-stage → 1.0.1

package/README.md

@@ -1,3 +1,166 @@
-# 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 gives you a simpler, more expressive syntax while staying fully compatible with the JavaScript ecosystem.
+
+[![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)
+[![Version](https://img.shields.io/badge/version-1.1.0-brightgreen)](package.json)
+
+---
+
+## Features
+
+- 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`
+- Optional runtime typing
+- Async with `sync fn` and `wait`
+- One-liners and stacking
+- CLI with flags and multiple commands
+
+---
+
+## Quick Start
+
+```bash
+# After publishing
+npm install -g cajyu
+
+# Or from source
+node bin/cajyu.js --help
+```
+
+```bash
+cajyu init
+cajyu inst serial
+cajyu inst http
+cajyu run examples/fatorial.cjy
+```
+
+---
+
+## CLI
+
+```
+cajyu [flags]
+cajyu <command> [options]
+```
+
+| Command          | Description                          |
+|------------------|--------------------------------------|
+| `init`           | Create a new project                 |
+| `inst <lib>`     | Install a library from CajyuLibs     |
+| `run <file.cjy>` | Compile and run a file               |
+| `list`           | List installed libraries             |
+| `update`         | Update libraries (planned)           |
+
+| Flag             | Description          |
+|------------------|----------------------|
+| `-h, --help`     | Show help            |
+| `-v, --version`  | Show version         |
+
+---
+
+## Syntax
+
+### Variables
+```cajyu
+var name = "Cajyu"
+var age:Number = 17
+```
+
+### Functions
+```cajyu
+fn add a, b {
+  return a + b
+}
+```
+
+### Control flow & loops
+```cajyu
+if x > 10 {
+  print("big")
+} elif x > 5 {
+  print("medium")
+} else {
+  print("small")
+}
+
+for i in range(10) {
+  print(i)
+}
+```
+
+### Classes
+```cajyu
+class Person {
+  Main name, age {
+    Self.name = name
+    Self.age = age
+  }
+  greet {
+    return "Hello, " + Self.name
+  }
+}
+```
+
+### HTTP
+```cajyu
+import Server from CajyuLibs.http
+
+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 }
+})
+```
+
+### WebSocket
+```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)
+})
+```
+
+---
+
+## Libraries
+
+Official libraries: https://github.com/abs-js/CajyuLibs
+
+```bash
+cajyu inst serial
+cajyu inst fs
+cajyu inst math
+cajyu inst http
+cajyu inst websocket
+```
+
+---
+
+## Contributing
+
+Pull requests are welcome. Priority areas:
+
+- A proper parser (current one is regex-based)
+- More language features
+- Additional libraries
+- Better error messages
+
+---
+
+## License
+
+MIT

package/bin/cajyu.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import { compileAndRun } from '../src/compiler.js';
+
+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 args = process.argv.slice(2);
+const command = args[0];
+const flags = args.filter(a => a.startsWith('-'));
+
+function hasFlag(...names) {
+  return names.some(n => flags.includes(n) || flags.includes(`-${n}`) || flags.includes(`--${n}`));
+}
+
+async function main() {
+  if (hasFlag('v', 'version', '--version')) {
+    console.log(`Cajyu ${VERSION}`);
+    return;
+  }
+
+  if (hasFlag('h', 'help', '--help') || !command) {
+    showHelp();
+    return;
+  }
+
+  if (command === 'init') {
+    initProject();
+  } else if (command === 'inst' || command === 'install') {
+    const libName = args[1];
+    if (!libName || libName.startsWith('-')) {
+      console.error('Usage: cajyu inst <library>');
+      process.exit(1);
+    }
+    await installLib(libName);
+  } else if (command === 'run') {
+    const file = args.find(a => a.endsWith('.cjy') || (a !== 'run' && !a.startsWith('-')));
+    if (!file) {
+      console.error('Usage: cajyu run <file.cjy>');
+      process.exit(1);
+    }
+    await compileAndRun(file);
+  } else if (command === 'list') {
+    listInstalled();
+  } else if (command === 'update') {
+    console.log('Updating is not yet implemented. Re-run `cajyu inst <lib>` after deleting the folder.');
+  } else {
+    console.error(`Unknown command: ${command}`);
+    showHelp();
+    process.exit(1);
+  }
+}
+
+function showHelp() {
+  console.log(`
+Cajyu ${VERSION} — a custom programming language that transpiles to JavaScript
+
+Usage:
+  cajyu [flags]
+  cajyu <command> [options]
+
+Commands:
+  init              Create a new Cajyu project
+  inst <lib>        Install a library from CajyuLibs
+  run <file.cjy>    Compile and execute a Cajyu file
+  list              List installed libraries
+  update            Update installed libraries (coming soon)
+
+Flags:
+  -h, --help        Show this help
+  -v, --version     Show version
+
+Examples:
+  cajyu init
+  cajyu inst http
+  cajyu inst websocket
+  cajyu run examples/fatorial.cjy
+  cajyu list
+`);
+}
+
+function initProject() {
+  const pkg = {
+    name: "cajyu-project",
+    version: "1.0.0",
+    description: "Cajyu project",
+    main: "index.cjy",
+    type: "module"
+  };
+  fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2));
+  if (!fs.existsSync('CajyuLibs')) fs.mkdirSync('CajyuLibs');
+  console.log('Cajyu project initialized.');
+}
+
+async function installLib(libName) {
+  console.log(`Installing "${libName}" from CajyuLibs...`);
+
+  const targetDir = path.join(process.cwd(), 'CajyuLibs', libName);
+  if (fs.existsSync(targetDir)) {
+    console.log(`Library "${libName}" already installed.`);
+    return;
+  }
+
+  const tmpDir = path.join('/tmp', `cajyulibs-${Date.now()}`);
+  try {
+    console.log('Cloning CajyuLibs repository...');
+    execSync(`git clone --depth 1 ${CAJYULIBS_REPO} ${tmpDir}`, { stdio: 'inherit' });
+
+    const sourceLib = path.join(tmpDir, libName);
+    if (!fs.existsSync(sourceLib)) {
+      console.error(`Library "${libName}" not found in CajyuLibs.`);
+      process.exit(1);
+    }
+
+    fs.mkdirSync(path.dirname(targetDir), { recursive: true });
+    fs.cpSync(sourceLib, targetDir, { recursive: true });
+
+    const pkgPath = path.join(targetDir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      if (pkg.dependencies && Object.keys(pkg.dependencies).length > 0) {
+        console.log('Installing library dependencies...');
+        execSync('npm install', { cwd: targetDir, stdio: 'inherit' });
+      }
+    }
+
+    console.log(`✓ Library "${libName}" installed to CajyuLibs/${libName}/`);
+  } catch (err) {
+    console.error('Failed to install library:', err.message);
+    process.exit(1);
+  } finally {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  }
+}
+
+function listInstalled() {
+  const libsDir = path.join(process.cwd(), 'CajyuLibs');
+  if (!fs.existsSync(libsDir)) {
+    console.log('No libraries installed yet.');
+    return;
+  }
+  const libs = fs.readdirSync(libsDir).filter(d => fs.statSync(path.join(libsDir, d)).isDirectory());
+  if (libs.length === 0) {
+    console.log('No libraries installed.');
+  } else {
+    console.log('Installed libraries:');
+    libs.forEach(l => console.log(`  - ${l}`));
+  }
+}
+
+main().catch(console.error);

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.01",
+  "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;');
+}