xanascript 2.0.0

package/src/pkgmgr.js

@@ -0,0 +1,273 @@
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+
+const XS_PACKAGE_REGISTRY = "https://api.xanascript.dev/packages";
+const XS_CACHE_DIR = path.join(process.env.HOME || process.env.USERPROFILE || ".xs", ".xs", "packages");
+const XS_PACKAGE_FILE = "xspack.json";
+
+export async function initProject(dir) {
+  dir = dir || ".";
+  const target = path.resolve(dir);
+  if (!fs.existsSync(target)) fs.mkdirSync(target, { recursive: true });
+
+  const pkgFile = path.join(target, XS_PACKAGE_FILE);
+  if (fs.existsSync(pkgFile)) {
+    console.log(" xspack.json já existe");
+    return;
+  }
+
+  const name = path.basename(target);
+  const pkg = {
+    name: name.toLowerCase().replace(/\s+/g, "-"),
+    version: "1.0.0",
+    description: "",
+    main: "src/index.xs",
+    dependencies: {},
+    xs_version: ">=2.0.0",
+  };
+
+  fs.writeFileSync(pkgFile, JSON.stringify(pkg, null, 2) + "\n");
+
+  const srcDir = path.join(target, "src");
+  if (!fs.existsSync(srcDir)) fs.mkdirSync(srcDir, { recursive: true });
+
+  const indexFile = path.join(srcDir, "index.xs");
+  if (!fs.existsSync(indexFile)) {
+    fs.writeFileSync(indexFile, `PARTIU()
+SOLTA O GRITO("Olá do pacote ${pkg.name}!")
+ACABOU()
+`);
+  }
+
+  const gitignore = path.join(target, ".gitignore");
+  if (!fs.existsSync(gitignore)) {
+    fs.writeFileSync(gitignore, "node_modules/\n.xs-cache/\n");
+  }
+
+  console.log(` Projeto XanaScript criado em ${target}`);
+  console.log(`  ${XS_PACKAGE_FILE}`);
+  console.log(`  src/index.xs`);
+  console.log("");
+  console.log("  Para instalar dependências:");
+  console.log("    xs install");
+  console.log("  Para publicar:");
+  console.log("    xs publish");
+}
+
+export async function installPackages(packages) {
+  if (!fs.existsSync(XS_CACHE_DIR)) {
+    fs.mkdirSync(XS_CACHE_DIR, { recursive: true });
+  }
+
+  if (packages.length === 0) {
+
+    const pkgFile = findPackageFile();
+    if (!pkgFile) {
+      console.log(" Nenhum xspack.json encontrado");
+      return;
+    }
+    const pkg = JSON.parse(fs.readFileSync(pkgFile, "utf-8"));
+    packages = Object.keys(pkg.dependencies || {});
+    if (packages.length === 0) {
+      console.log(" Nenhuma dependência para instalar");
+      return;
+    }
+  }
+
+  for (const pkgName of packages) {
+    const [name, version] = pkgName.includes("@")
+      ? pkgName.split("@")
+      : [pkgName, "latest"];
+
+    console.log(` Instalando ${name}...`);
+
+    try {
+
+      const installed = await installFromRegistry(name, version);
+
+      if (installed) {
+
+        const pkgFile = findPackageFile();
+        if (pkgFile) {
+          const pkg = JSON.parse(fs.readFileSync(pkgFile, "utf-8"));
+          if (!pkg.dependencies) pkg.dependencies = {};
+          pkg.dependencies[name] = version;
+          fs.writeFileSync(pkgFile, JSON.stringify(pkg, null, 2) + "\n");
+        }
+        console.log(`   ${name}@${version}`);
+      }
+    } catch (e) {
+      console.error(`   ${name}: ${e.message}`);
+    }
+  }
+}
+
+async function installFromRegistry(name, version) {
+
+  const searchUrl = `https://api.github.com/search/repositories?q=${name}+language:xs`;
+
+  try {
+    const res = await fetch(searchUrl, {
+      headers: { "Accept": "application/vnd.github.v3+json" }
+    });
+
+    if (!res.ok) throw new Error(`GitHub API: ${res.status}`);
+
+    const data = await res.json();
+    const repo = data.items?.find(r =>
+      r.name.toLowerCase() === name.toLowerCase() ||
+      r.full_name.toLowerCase() === name.toLowerCase()
+    );
+
+    if (!repo) {
+
+      return installFromNpm(name, version);
+    }
+
+    const distDir = path.join(XS_CACHE_DIR, name);
+    if (!fs.existsSync(distDir)) fs.mkdirSync(distDir, { recursive: true });
+
+    const pkgUrl = `https://raw.githubusercontent.com/${repo.full_name}/main/xspack.json`;
+    const pkgRes = await fetch(pkgUrl);
+
+    if (pkgRes.ok) {
+      const pkgData = await pkgRes.json();
+      fs.writeFileSync(path.join(distDir, XS_PACKAGE_FILE), JSON.stringify(pkgData, null, 2));
+    }
+
+    const srcUrl = `https://raw.githubusercontent.com/${repo.full_name}/main/src/index.xs`;
+    const srcRes = await fetch(srcUrl);
+
+    if (srcRes.ok) {
+      const code = await srcRes.text();
+      const srcDir = path.join(distDir, "src");
+      if (!fs.existsSync(srcDir)) fs.mkdirSync(srcDir, { recursive: true });
+      fs.writeFileSync(path.join(srcDir, "index.xs"), code);
+    }
+
+    return true;
+  } catch (e) {
+
+    return installFromNpm(name, version);
+  }
+}
+
+async function installFromNpm(name, version) {
+
+  try {
+    const npmUrl = `https://registry.npmjs.org/xanascript-${name}/latest`;
+    const res = await fetch(npmUrl);
+
+    if (!res.ok) throw new Error(`Pacote ${name} não encontrado`);
+
+    const data = await res.json();
+    const ver = version === "latest" ? data["dist-tags"]?.latest : version;
+    const pkgVersion = data.versions?.[ver];
+
+    if (!pkgVersion) throw new Error(`Versão ${ver} não encontrada`);
+
+    const distDir = path.join(XS_CACHE_DIR, name);
+    if (!fs.existsSync(distDir)) fs.mkdirSync(distDir, { recursive: true });
+
+    fs.writeFileSync(path.join(distDir, XS_PACKAGE_FILE), JSON.stringify({
+      name, version: ver,
+      description: pkgVersion.description || "",
+      main: "src/index.xs",
+    }, null, 2));
+
+    if (pkgVersion.dist?.tarball) {
+      const tarballRes = await fetch(pkgVersion.dist.tarball);
+
+      console.log(`   npm package: ${pkgVersion.dist.tarball}`);
+    }
+
+    return true;
+  } catch (e) {
+    throw new Error(`Pacote não encontrado em nenhum registro: ${name}`);
+  }
+}
+
+export async function publishPackage() {
+  const pkgFile = findPackageFile();
+  if (!pkgFile) {
+    console.log(" xspack.json não encontrado");
+    console.log("  Crie um com: xs init");
+    return;
+  }
+
+  const pkg = JSON.parse(fs.readFileSync(pkgFile, "utf-8"));
+  console.log(` Publicando ${pkg.name} v${pkg.version}...`);
+  console.log("");
+  console.log("  Para publicar seu pacote XanaScript:");
+  console.log("  1. Crie um repositório no GitHub");
+  console.log("  2. Adicione o tópico 'xanascript-package'");
+  console.log("  3. Commit seu código na branch main");
+  console.log("");
+  console.log("  Estrutura esperada:");
+  console.log("    xspack.json");
+  console.log("    src/index.xs      ← entry point");
+  console.log("    README.xs.md      ← documentação");
+  console.log("");
+  console.log("  Exemplo de xspack.json:");
+  console.log("    {");
+  console.log(`      "name": "${pkg.name}",`);
+  console.log(`      "version": "${pkg.version}",`);
+  console.log('      "description": "...",');
+  console.log('      "main": "src/index.xs",');
+  console.log('      "dependencies": {}');
+  console.log("    }");
+  console.log("");
+  console.log("  Após publicar no GitHub, outros devs podem instalar com:");
+  console.log(`    xs install ${pkg.name}`);
+}
+
+export async function searchPackages(query) {
+  console.log(` Buscando pacotes XanaScript...`);
+
+  try {
+  const searchUrl = `https://api.github.com/search/repositories?q=${name}+language:xs`;
+
+    const res = await fetch(searchUrl, {
+      headers: { "Accept": "application/vnd.github.v3+json" }
+    });
+
+    if (!res.ok) throw new Error(`GitHub API: ${res.status}`);
+
+    const data = await res.json();
+
+    if (data.items?.length > 0) {
+      console.log(`\n  ${data.items.length} pacote(s) encontrado(s):\n`);
+      for (const repo of data.items.slice(0, 20)) {
+        console.log(`   ${repo.full_name}`);
+        console.log(`      ⭐ ${repo.stargazers_count}  |  ${repo.description || "Sem descrição"}`);
+        console.log(`      ${repo.html_url}`);
+        console.log("");
+      }
+    } else {
+      console.log("  Nenhum pacote encontrado.");
+      console.log("  Dica: crie um repositório GitHub e adicione");
+      console.log("  o tópico 'xanascript-package'");
+    }
+  } catch (e) {
+    console.error(`   Erro na busca: ${e.message}`);
+  }
+}
+
+function findPackageFile() {
+  let dir = process.cwd();
+  while (dir !== path.dirname(dir)) {
+    const pkgFile = path.join(dir, XS_PACKAGE_FILE);
+    if (fs.existsSync(pkgFile)) return pkgFile;
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+export function getInstalledPackages() {
+  if (!fs.existsSync(XS_CACHE_DIR)) return [];
+  return fs.readdirSync(XS_CACHE_DIR).filter(d => {
+    const pkgFile = path.join(XS_CACHE_DIR, d, XS_PACKAGE_FILE);
+    return fs.existsSync(pkgFile);
+  });
+}

package/src/runtime.js

@@ -0,0 +1,171 @@
+import fs from "fs";
+import path from "path";
+import http from "http";
+import axios from "axios";
+
+import { lex } from "./lexer.js";
+import { parse } from "./parser.js";
+import { optimize } from "./optimizer.js";
+import { interpret, setTabelas } from "./interpreter.js";
+import { setSource, XSError, formatError } from "./errors.js";
+import { criarRepositorio } from "./orm.js";
+
+const CACHE = new Map();
+const LOADING = new Set();
+
+export async function runXS(code, baseDir = process.cwd(), fileName = "input.xs") {
+  setSource(code, fileName);
+
+  const tokens = lex(code, fileName);
+
+  let ast = parse(tokens);
+  ast = optimize(ast);
+
+  const env = createEnv(baseDir);
+  return interpret(ast, env);
+}
+
+export function createEnv(baseDir) {
+  const servers = new Set();
+
+  const builtins = {
+
+    SOLTA_O_GRITO: (...a) => console.log(...a),
+    FALA_BAIXO: (...a) => console.warn(...a),
+
+    AGORA: () => Date.now(),
+
+    AGORA_VAI: async url => {
+      try {
+        const res = await axios.get(url, { timeout: 3000 });
+        return res.data;
+      } catch (e) {
+        throw new XSError(`Falha em AGORA_VAI("${url}"): ${e.message}`, {
+          hint: "Verifique se a URL está correta e acessível",
+          code: "E100",
+        });
+      }
+    },
+
+    ESPERA_AI: ms => new Promise(r => setTimeout(r, ms)),
+    SORTEIA: (a, b) => Math.floor(Math.random() * (b - a + 1)) + a,
+    PARSEIA: JSON.parse,
+    OUVE_AQUI: k => process.env[k] ?? null,
+
+    CRIA_SERVIDOR: (port, handler) => {
+      const server = http.createServer(async (req, res) => {
+        const resposta = {
+          enviar: (dados, tipo) => {
+            if (tipo) res.setHeader("Content-Type", tipo);
+            res.end(String(dados));
+          },
+          json: (dados) => {
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify(dados));
+          },
+          status: (codigo) => {
+            res.statusCode = codigo;
+            return resposta;
+          },
+          cabecalho: (chave, valor) => {
+            res.setHeader(chave, valor);
+            return resposta;
+          },
+        };
+
+        const requisicao = {
+          url: req.url,
+          metodo: req.method,
+          cabecalhos: req.headers,
+          corpo: await new Promise(resolve => {
+            let body = "";
+            req.on("data", c => body += c);
+            req.on("end", () => resolve(body));
+          }),
+        };
+
+        try {
+          await handler(requisicao, resposta);
+        } catch (e) {
+          res.statusCode = 500;
+          res.end("Erro interno: " + e.message);
+        }
+      });
+
+      server.listen(port, () => {
+        console.log(` Servidor rodando em http://localhost:${port}`);
+      });
+
+      servers.add(server);
+      return server;
+    },
+
+    PARA_SERVIDOR: (server) => {
+      server.close();
+      servers.delete(server);
+      console.log(" Servidor parado");
+    },
+
+    CRIA_REPOSITORIO: (nomeTabela) => {
+      const t = TABELAS[nomeTabela];
+      const props = t?.props || [];
+      return criarRepositorio(nomeTabela, props);
+    },
+
+    __IMPORT__: async mod => {
+      let full;
+      if (mod.startsWith(".") || mod.startsWith("/")) {
+        full = path.resolve(baseDir, mod);
+      } else {
+        full = mod;
+        return await importNodeModule(mod);
+      }
+      if (CACHE.has(full)) {
+        return CACHE.get(full);
+      }
+      if (LOADING.has(full)) {
+        throw new XSError(`Import cíclico detectado: ${mod}`, {
+          hint: "Dois arquivos se importam mutuamente",
+          code: "E101",
+        });
+      }
+      LOADING.add(full);
+      const code = fs.readFileSync(full, "utf-8");
+      const exports = {};
+      const env2 = createEnv(path.dirname(full));
+      env2.EXPORTA = (name, value) => { exports[name] = value; };
+      await runModule(code, env2);
+      CACHE.set(full, exports);
+      LOADING.delete(full);
+      return exports;
+    }
+  };
+  return builtins;
+}
+
+async function importNodeModule(name) {
+  try {
+    const mod = await import(name);
+    return mod.default || mod;
+  } catch (e) {
+    throw new XSError(`Falha ao importar módulo "${name}": ${e.message}`, {
+      hint: "Verifique se o pacote está instalado (npm install)",
+      code: "E102",
+    });
+  }
+}
+
+async function runModule(code, env) {
+  const tokens = lex(code);
+
+  let ast = parse(tokens);
+  ast = optimize(ast);
+
+  for (const stmt of ast.body) {
+    if (stmt.type === "ExportStmt") {
+      env.EXPORTA(stmt.name, env[stmt.name]);
+      continue;
+    }
+    await interpret(stmt, env);
+  }
+}

package/src/sourcemap.js

@@ -0,0 +1,120 @@
+export class SourceMap {
+  constructor(sourceFile, xsSource) {
+    this.file = sourceFile || "input.xs";
+    this.xsLines = xsSource?.split("\n") || [];
+    this.mappings = [];
+    this.generated = "";
+  }
+
+  addXsLine(xsLine, jsCode) {
+    const currentJsLine = (this.generated.match(/\n/g) || []).length + 1;
+    this.mappings.push({ jsLine: currentJsLine, xsLine });
+    this.generated += jsCode;
+    return jsCode;
+  }
+
+  add(jsCode) {
+    this.generated += jsCode;
+    return jsCode;
+  }
+
+  translateError(error) {
+    if (!error || !error.stack) return error;
+    const stack = error.stack;
+    const lines = stack.split("\n");
+
+    const translated = lines.map(line => {
+
+      const match = line.match(/:(\d+):\d+/);
+      if (!match) return line;
+      const jsLine = parseInt(match[1]);
+
+      let bestXsLine = null;
+      for (const m of this.mappings) {
+        if (m.jsLine <= jsLine) {
+          bestXsLine = m.xsLine;
+        } else break;
+      }
+
+      if (bestXsLine !== null) {
+        const xsContent = this.xsLines[bestXsLine - 1]?.trim() || "";
+        return line.replace(/:(\d+):(\d+)/, `:${bestXsLine}:1`) +
+          `  ← xs:${bestXsLine} ${xsContent}`;
+      }
+      return line;
+    });
+
+    error.stack = translated.join("\n");
+    error.xsLine = this._findXsLine(error);
+    return error;
+  }
+
+  _findXsLine(error) {
+    const match = error.stack?.match(/xs:(\d+)/);
+    return match ? parseInt(match[1]) : null;
+  }
+
+  toComment() {
+    const data = {
+      file: this.file,
+      version: 1,
+      mappings: this.mappings,
+    };
+    return `\n//# sourceMappingURL=data:application/json;base64,${btoa(JSON.stringify(data))}\n`;
+  }
+
+  static fromComment(comment, xsLines) {
+    const match = comment.match(/sourceMap=(\{.+?\})/);
+    if (!match) return null;
+    try {
+      const data = JSON.parse(match[1]);
+      const sm = new SourceMap(data.file, xsLines?.join("\n"));
+      sm.mappings = data.mappings;
+      return sm;
+    } catch { return null; }
+  }
+
+  static getRuntimeWrapper() {
+    return `
+
+const __xs_handler = {
+  wrap(fn, sourceMap) {
+    if (!sourceMap) return fn;
+    return function(...args) {
+      try {
+        return fn.apply(this, args);
+      } catch (e) {
+        const lines = (e.stack || "").split("\\\\n");
+        e.stack = lines.map(l => {
+          const m = l.match(/:(\\\\d+):\\\\d+/);
+          if (!m) return l;
+          const jsLine = parseInt(m[1]);
+          let best = null;
+          sourceMap.mappings.some(m => { if (m.jsLine <= jsLine) { best = m.xsLine; return false; } return true; });
+          if (best) l = l.replace(/:(\\\\d+):\\\\d+/, ":" + best + ":1") + "  ← xs:" + best;
+          return l;
+        }).join("\\\\n");
+        throw e;
+      }
+    };
+  }
+};`;
+  }
+}
+
+export function generateWithSourceMap(ast, codegenFn, sourceFile, xsCode) {
+  const sm = new SourceMap(sourceFile, xsCode);
+  const code = codegenFn(ast);
+  return { code, sourceMap: sm };
+}
+
+export function buildSourceMap(xsLines, statements) {
+  const sm = new SourceMap("input.xs", xsLines.join("\n"));
+  let jsLine = 1;
+  for (const stmt of statements) {
+    const xsLine = stmt.loc?.start?.line || stmt.xsLine || 1;
+    sm.mappings.push({ jsLine, xsLine });
+    jsLine += (stmt.generatedJs?.match(/\n/g) || []).length + 1;
+  }
+  return sm;
+}

package/src/testrunner.js

@@ -0,0 +1,118 @@
+import fs from "fs";
+import path from "path";
+import { lex } from "./lexer.js";
+import { parse } from "./parser.js";
+import { optimize } from "./optimizer.js";
+import { interpret, AssertionError } from "./interpreter.js";
+import { createEnv } from "./runtime.js";
+import { setSource, XSError } from "./errors.js";
+
+export async function runTests(dir = ".") {
+  const start = Date.now();
+  const root = path.resolve(dir);
+
+  console.log("");
+  console.log("╔══════════════════════════════════════╗");
+  console.log("║       XanaScript Test Runner         ║");
+  console.log("╚══════════════════════════════════════╝");
+  console.log("");
+
+  const testFiles = findTestFiles(root);
+
+  if (testFiles.length === 0) {
+    console.log("  Nenhum arquivo de teste encontrado (*test*.xs)");
+    console.log("");
+    return;
+  }
+
+  console.log(`   ${testFiles.length} arquivo(s) encontrado(s)\n`);
+
+  let totalPassed = 0;
+  let totalFailed = 0;
+  const failures = [];
+
+  for (const file of testFiles) {
+    const relPath = path.relative(root, file);
+    console.log(`   ${relPath}`);
+
+    const code = fs.readFileSync(file, "utf-8");
+    const results = await runTestFile(code, file);
+
+    for (const r of results) {
+      if (r.passed) {
+        console.log(`     ${r.name}`);
+        totalPassed++;
+      } else {
+        console.log(`     ${r.name}`);
+        console.log(`       ${r.error}`);
+        totalFailed++;
+        failures.push({ file: relPath, name: r.name, error: r.error });
+      }
+    }
+
+    if (results.length === 0) {
+      console.log(`     Nenhum TESTE encontrado`);
+    }
+
+    console.log("");
+  }
+
+  const elapsed = ((Date.now() - start) / 1000).toFixed(2);
+  console.log("──────────────────────────────────────");
+  console.log(`   ${totalPassed} passaram   ${totalFailed} falharam`);
+  console.log(`   ${elapsed}s`);
+  console.log("");
+
+  if (failures.length > 0) {
+    console.log("  Falhas:");
+    for (const f of failures) {
+      console.log(`    ${f.file} > ${f.name}: ${f.error}`);
+    }
+    console.log("");
+    process.exit(1);
+  }
+}
+
+export async function runTestFile(code, filePath) {
+  const results = [];
+  const env = createEnv(path.dirname(filePath));
+  env.__testResults = results;
+
+  env.AFIRMA = (cond) => {
+    if (!cond) throw new AssertionError("AFIRMA recebeu falso");
+  };
+  env.ASSUNTO = (a, b) => {
+    if (a != b) throw new AssertionError(`ASSUNTO falhou: ${JSON.stringify(a)} != ${JSON.stringify(b)}`);
+  };
+
+  try {
+    setSource(code, filePath);
+    const tokens = lex(code, filePath);
+    let ast = parse(tokens);
+    ast = optimize(ast);
+    await interpret(ast, env);
+  } catch (e) {
+    if (!(e instanceof AssertionError)) {
+      results.push({ name: "Erro no arquivo", passed: false, error: e.message });
+    }
+  }
+
+  return results;
+}
+
+function findTestFiles(dir) {
+  const files = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith(".")) {
+      files.push(...findTestFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".xs") && entry.name.toLowerCase().includes("test")) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}