@thiagodiogo/psjava 0.0.1-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 thiagodiogo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# psjava
+
+Roda arquivos `.psjava` como script — Java puro, em cima do [JShell](https://docs.oracle.com/javase/9/jshell/). Sem transformação de sintaxe: o que está no arquivo é o que o `jshell` executa.
+
+```bash
+psjava exemplo.psjava # executa o arquivo
+psjava exemplo.psjava --debug  # idem, e loga o tempo da execução ao final
+psjava doctor         # verifica se o jshell está disponível
+```
+
+```java
+var nome = "mundo";
+print("olá, " + nome);
+```
+
+## Helper `print`
+
+O psjava define um `print(...)` na sessão antes do teu código (Java puro, teu
+arquivo continua intocado). Tem overload para `String`, `int[]` e `List`:
+
+```java
+print("texto");                      // texto
+print(new int[]{1, 2, 3});           // [1, 2, 3]
+print(java.util.List.of("a", "b"));  // [a, b]
+```
+
+`System.out.println(...)` continua funcionando normalmente.
+
+## Requisitos
+
+Um JDK 11+ com `jshell` no PATH. Confirme com `psjava doctor`.
+
+## Dev
+
+```bash
+npm install
+npm test          # unit + e2e
+npm run test:unit # só lógica pura (sem JDK)
+npm run test:e2e  # builda e roda no jshell (precisa de JDK; pula sozinho sem ele)
+```
+
+A única coisa que o `psjava` mexe no arquivo é remover o BOM do Windows, que o
+`jshell` não engole. Fora isso, é Java puro entrando no JShell.

package/bin/psjava.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runCli } from '../dist/cli.js';
+runCli();

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function buildProgram(): Command;
+export declare function runCli(argv?: string[]): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,26 @@
+import { Command } from 'commander';
+import { runFile } from './commands/run.js';
+import { runDoctor } from './commands/doctor.js';
+export function buildProgram() {
+    const program = new Command();
+    program.name('psjava').description('Roda arquivos .psjava').version('0.1.0');
+    program
+        .argument('[file]', 'arquivo .psjava')
+        .option('-d, --debug', 'imprime o tempo da execução ao final')
+        .action(async (file, opts) => {
+        if (!file)
+            return program.help();
+        await runFile(file, opts.debug);
+    });
+    program.command('doctor').description('Verifica o JDK (jshell)').action(runDoctor);
+    return program;
+}
+export async function runCli(argv = process.argv) {
+    try {
+        await buildProgram().parseAsync(argv);
+    }
+    catch (err) {
+        console.error(`\nErro: ${err instanceof Error ? err.message : String(err)}`);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1 @@
+export declare function runDoctor(): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,12 @@
+import chalk from 'chalk';
+import { resolveJshell } from '../core/jdk.js';
+export async function runDoctor() {
+    try {
+        await resolveJshell();
+        console.log(chalk.green('✓ jshell encontrado — pronto pra rodar .psjava'));
+    }
+    catch (err) {
+        console.log(chalk.red(`✗ ${err instanceof Error ? err.message : String(err)}`));
+        process.exitCode = 1;
+    }
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,3 @@
+/** Nomes a tentar. Só roda .psjava; sem extensão, assume .psjava. Outra extensão é recusada. */
+export declare function scriptCandidates(file: string): string[];
+export declare function runFile(file: string, debug?: boolean): Promise<void>;

package/dist/commands/run.js

@@ -0,0 +1,26 @@
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { runSource } from '../core/runner.js';
+/** Nomes a tentar. Só roda .psjava; sem extensão, assume .psjava. Outra extensão é recusada. */
+export function scriptCandidates(file) {
+    if (file.endsWith('.psjava'))
+        return [file];
+    const base = file.split(/[/\\]/).pop() ?? file;
+    if (base.includes('.'))
+        return []; // tem outra extensão (.java etc) → psjava não roda
+    return [`${file}.psjava`]; // sem extensão → .psjava implícito
+}
+export async function runFile(file, debug = false) {
+    const tried = scriptCandidates(file);
+    if (tried.length === 0) {
+        throw new Error(`psjava só roda arquivos .psjava (recebi: ${file})`);
+    }
+    const found = tried.find((f) => existsSync(f));
+    if (!found) {
+        throw new Error(`não encontrei o arquivo. Tentei: ${tried.join(', ')}`);
+    }
+    const source = await readFile(found, 'utf8');
+    const code = await runSource(source, debug);
+    if (code !== 0)
+        process.exitCode = code;
+}

package/dist/core/jdk.d.ts

@@ -0,0 +1,2 @@
+/** Acha o jshell no PATH e confirma que roda. Lança erro amigável se faltar. */
+export declare function resolveJshell(): Promise<string>;

package/dist/core/jdk.js

@@ -0,0 +1,13 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+const exec = promisify(execFile);
+/** Acha o jshell no PATH e confirma que roda. Lança erro amigável se faltar. */
+export async function resolveJshell() {
+    try {
+        await exec('jshell', ['--version']);
+        return 'jshell';
+    }
+    catch {
+        throw new Error('jshell não encontrado. Instale um JDK (11+) e garanta que o jshell está no PATH.');
+    }
+}

package/dist/core/runner.d.ts

@@ -0,0 +1,3 @@
+/** Monta o que vai pro jshell: preâmbulo + código do usuário (só tira o BOM do Windows). */
+export declare function buildSession(source: string): string;
+export declare function runSource(source: string, debug?: boolean): Promise<number>;

package/dist/core/runner.js

@@ -0,0 +1,30 @@
+import { spawn } from 'child_process';
+import chalk from 'chalk';
+import { resolveJshell } from './jdk.js';
+// Helpers definidos na sessão antes do código do usuário — Java puro, ele só chama print(...).
+const PRELUDE = [
+    'void print(String s) { System.out.println(s); }',
+    'void print(int[] a) { System.out.println(java.util.Arrays.toString(a)); }',
+    'void print(java.util.List<?> l) { System.out.println(l); }',
+].join('\n');
+/** Monta o que vai pro jshell: preâmbulo + código do usuário (só tira o BOM do Windows). */
+export function buildSession(source) {
+    return `${PRELUDE}\n${source.replace(/^/, '')}`; // ponytail: BOM é lixo de encoding, não é edição do código
+}
+export async function runSource(source, debug = false) {
+    const jshell = await resolveJshell(); // erro amigável se faltar JDK
+    const code = buildSession(source);
+    const start = performance.now();
+    return new Promise((resolve) => {
+        // -s: modo script silencioso (sem banner/prompt); lê de stdin e sai sozinho
+        const p = spawn(jshell, ['-s', '-'], { stdio: ['pipe', 'inherit', 'inherit'] });
+        p.stdin.end(code + '\n');
+        p.on('close', (c) => {
+            if (debug) {
+                const s = ((performance.now() - start) / 1000).toFixed(2);
+                console.error(chalk.dim(`[psjava] concluído em ${s}s`));
+            }
+            resolve(c ?? 0);
+        });
+    });
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@thiagodiogo/psjava",
+  "version": "0.0.1-beta.0",
+  "description": "Roda arquivos .psjava como script — Java sem cerimônia, em cima do JShell.",
+  "keywords": [
+    "psjava",
+    "java",
+    "jshell",
+    "cli",
+    "script"
+  ],
+  "homepage": "https://github.com/eipastel/psjava",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eipastel/psjava.git"
+  },
+  "bugs": {
+    "url": "https://github.com/eipastel/psjava/issues"
+  },
+  "license": "MIT",
+  "author": "thiagodiogo",
+  "type": "module",
+  "bin": {
+    "psjava": "bin/psjava.js"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prebuild": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "npm run test:unit && npm run test:e2e",
+    "test:unit": "vitest run",
+    "test:e2e": "npm run build && vitest run --config vitest.e2e.config.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "chalk": "^5.5.0",
+    "commander": "^14.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24",
+    "typescript": "^5.9",
+    "vitest": "^3"
+  }
+}