@jasy/cli 1.0.0-alpha.1

package/dist/tui/app.js

@@ -0,0 +1,356 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { readFileSync, writeFileSync } from "node:fs";
+import { basename, resolve, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createScreen, createDraw, createInputManager } from "@jano-editor/ui";
+import { readInvoice } from "../core/read.js";
+import { describeInvoice } from "../core/detect.js";
+import { checkPdfA3 } from "../core/pdfa.js";
+import { validateInvoiceXml, profileFor } from "../core/validate.js";
+import { exportInvoice } from "../core/export.js";
+import { detectTools } from "../core/verapdf.js";
+import { openFileDialog } from "./file-open.js";
+// The interactive jasy terminal: `o` opens a file picker, then the loaded invoice is shown together
+// with its checks - EN 16931 business rules + structural PDF/A-3. Same core as the `jasy read` command.
+const BRAND = [26, 79, 138];
+const INK = [230, 234, 240];
+const MUTED = [123, 135, 148];
+const FAINT = [80, 85, 95];
+const OK = [90, 170, 110];
+const ERR = [200, 90, 90];
+const YELLOW = [243, 220, 41]; // JS yellow - the ▒ accent band on the crane
+// the jasy origami crane (assets/jasy.txt), shown on the empty start screen; "▒" cells are the accent
+const CRANE = (() => {
+    try {
+        const p = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "assets", "jasy.txt");
+        return readFileSync(p, "utf-8")
+            .replace(/\n+$/, "")
+            .split("\n")
+            .map((l) => l.replace(/\s+$/, "")); // keep leading spaces (alignment), drop trailing
+    }
+    catch (_a) {
+        return []; // no logo file - the start screen just shows the box
+    }
+})();
+const CRANE_W = CRANE.length ? Math.max(...CRANE.map((l) => l.length)) : 0;
+const TOP = 1;
+const MAX_W = 72; // cap so the box doesn't sprawl on very wide terminals
+// clip a line so it never spills past the framed box
+const fit = (s, max) => (s.length > max ? s.slice(0, max - 1) + "…" : s);
+const money = (n) => n.toFixed(2);
+export function launchTui() {
+    if (!process.stdout.isTTY || !process.stdin.isTTY) {
+        console.log("jasy - ZUGFeRD / XRechnung terminal. Run me in an interactive terminal (or try `jasy read <file>`).");
+        process.exit(0);
+    }
+    const screen = createScreen();
+    const draw = createDraw(screen);
+    const input = createInputManager();
+    let loaded = null;
+    let error = null;
+    let notice = null; // last export result, shown in the footer
+    let scroll = 0; // first visible body row (the body scrolls; the header stays pinned)
+    let pageSize = 1; // body rows per screen, set in render() - used by PgUp/PgDn
+    // checked once at startup: is the optional full-ISO PDF/A validator (veraPDF) ready to run?
+    const tools = detectTools();
+    const veraReady = !!(tools.verapdf && tools.java);
+    // The pinned top: a one-line confirmation of which file + what it is (stays put while body scrolls).
+    function buildHeader(w) {
+        if (error || !loaded)
+            return [];
+        const { read } = loaded;
+        return [
+            { text: fit("✓ " + basename(loaded.path), w - 6), fg: OK },
+            {
+                text: fit(describeInvoice(read.meta) + " · " + read.xml.length + " B XML", w - 6),
+                fg: MUTED,
+            },
+        ];
+    }
+    // The scrollable body: the parsed invoice + its checks (or the empty / error message).
+    function buildBody(w) {
+        if (error)
+            return [{ text: fit("✗ " + error, w - 6), fg: ERR }];
+        if (!loaded) {
+            const rows = [
+                { text: "No invoice loaded.", fg: MUTED },
+                { text: "", fg: MUTED },
+                { text: "Open a ZUGFeRD / XRechnung PDF or XML -", fg: MUTED },
+                { text: "jasy extracts the XML, identifies it, and checks it.", fg: MUTED },
+                { text: "", fg: MUTED },
+            ];
+            // full-ISO PDF/A is optional (veraPDF) - tell the user how to enable it right here
+            if (veraReady) {
+                rows.push({ text: "Full PDF/A check (veraPDF)", fg: MUTED, status: "ready", statusFg: OK });
+            }
+            else {
+                rows.push({ text: "Full PDF/A check (veraPDF): not set up", fg: MUTED });
+                rows.push({ text: "→ run  jasy verapdf  to enable it", fg: FAINT });
+            }
+            return rows;
+        }
+        const { read, pdfa, rules } = loaded;
+        const rows = [];
+        // the parsed invoice itself (number, parties, lines, totals)
+        const inv = read.invoice;
+        if (inv && read.totals) {
+            const t = read.totals;
+            rows.push({ text: fit(inv.number, w - 16), fg: INK, status: inv.issueDate, statusFg: MUTED });
+            rows.push({ text: fit(`${inv.seller.name}  →  ${inv.buyer.name}`, w - 6), fg: MUTED });
+            rows.push({ text: "", fg: MUTED });
+            for (const [i, l] of inv.lines.entries()) {
+                rows.push({
+                    text: fit(`${l.quantity} ${l.unit}  ${l.name}`, w - 14),
+                    fg: INK,
+                    status: money(t.lineNets[i]),
+                    statusFg: MUTED,
+                });
+            }
+            rows.push({
+                text: `net ${money(t.taxBasisTotal)}   VAT ${money(t.taxTotal)}`,
+                fg: MUTED,
+                status: `${money(t.grandTotal)} ${inv.currency}`,
+                statusFg: INK,
+            });
+            rows.push({ text: "", fg: MUTED });
+        }
+        // XML business rules (Schematron) - EN 16931, + XRechnung BR-DE when applicable
+        rows.push({
+            text: (rules === null || rules === void 0 ? void 0 : rules.profile.startsWith("xrechnung")) ? "XRechnung rules" : "EN 16931 rules",
+            fg: INK,
+            status: rules ? (rules.valid ? "OK" : `${rules.errors.length} errors`) : "n/a",
+            statusFg: rules ? (rules.valid ? OK : ERR) : FAINT,
+        });
+        if (rules && !rules.valid) {
+            for (const e of rules.errors.slice(0, 4)) {
+                rows.push({ text: fit("  ✗ " + (e.id ? `[${e.id}] ` : "") + e.text, w - 6), fg: ERR });
+            }
+        }
+        // structural PDF/A-3 (per check)
+        rows.push({ text: "", fg: MUTED });
+        rows.push({
+            text: "PDF/A-3 structure",
+            fg: INK,
+            status: pdfa ? `${pdfa.checks.filter((c) => c.ok).length}/${pdfa.checks.length}` : "raw XML",
+            statusFg: pdfa ? (pdfa.ok ? OK : ERR) : FAINT,
+        });
+        if (pdfa) {
+            for (const c of pdfa.checks) {
+                rows.push({
+                    text: fit("  " + c.label, w - 14),
+                    fg: MUTED,
+                    status: c.ok ? "OK" : "FAILED",
+                    statusFg: c.ok ? OK : ERR,
+                });
+            }
+        }
+        return rows;
+    }
+    // draw the crane logo centred above the box: "▒" cells in JS-yellow, the rest in brand blue
+    function drawCrane(cols) {
+        const cx = Math.max(0, Math.floor((cols - CRANE_W) / 2));
+        CRANE.forEach((line, row) => {
+            let i = 0;
+            while (i < line.length) {
+                if (line[i] === " ") {
+                    i++;
+                    continue;
+                }
+                const yellow = line[i] === "▒";
+                let j = i;
+                while (j < line.length && line[j] !== " " && (line[j] === "▒") === yellow)
+                    j++;
+                draw.text(cx + i, TOP + row, line.slice(i, j), { fg: yellow ? YELLOW : BRAND });
+                i = j;
+            }
+        });
+    }
+    function render() {
+        const cols = screen.width;
+        const screenH = screen.height;
+        const w = Math.max(44, Math.min(cols - 2, MAX_W));
+        const x = Math.max(1, Math.floor((cols - w) / 2)); // centre the box
+        const statusEnd = x + w - 3;
+        const header = buildHeader(w); // pinned
+        const body = buildBody(w); // scrollable
+        const canExport = !!((loaded === null || loaded === void 0 ? void 0 : loaded.read.invoice) && loaded.read.totals);
+        // the crane sits above the box - only on the true start screen (nothing loaded) and only if it fits
+        const showCrane = !loaded && !error && CRANE.length > 0 && cols >= CRANE_W && screenH >= CRANE.length + 9;
+        const boxTop = TOP + (showCrane ? CRANE.length + 1 : 0);
+        // fit the box to the terminal height: pin the header, scroll the body in whatever is left
+        const headBlock = header.length ? header.length + 1 : 0; // header rows + a separator blank
+        const overhead = 5 + headBlock + (notice ? 1 : 0); // borders + blanks + footer around the body
+        const maxBodyH = Math.max(1, screenH - boxTop - overhead);
+        const viewH = Math.min(body.length, maxBodyH);
+        pageSize = viewH;
+        const maxScroll = Math.max(0, body.length - viewH);
+        scroll = Math.max(0, Math.min(scroll, maxScroll));
+        const visible = body.slice(scroll, scroll + viewH);
+        const boxH = 5 + headBlock + viewH + (notice ? 1 : 0);
+        const drawRow = (r, y) => {
+            var _a;
+            draw.text(x + 2, y, r.text, { fg: r.fg });
+            if (r.status)
+                draw.text(statusEnd - r.status.length, y, r.status, { fg: (_a = r.statusFg) !== null && _a !== void 0 ? _a : r.fg });
+        };
+        draw.clear();
+        if (showCrane)
+            drawCrane(cols);
+        draw.rect(x, boxTop, w, boxH, { border: "round" });
+        draw.text(x + 2, boxTop, " jasy · ZUGFeRD / XRechnung ", { fg: BRAND });
+        let y = boxTop + 2;
+        for (const r of header)
+            drawRow(r, y++);
+        if (header.length)
+            y++; // separator blank
+        const bodyTop = y;
+        for (const r of visible)
+            drawRow(r, y++);
+        // scrollbar on the right inner edge, only when the body overflows the viewport
+        if (maxScroll > 0) {
+            const thumbH = Math.max(1, Math.round((viewH * viewH) / body.length));
+            const thumbAt = Math.round((scroll * (viewH - thumbH)) / maxScroll);
+            for (let i = 0; i < viewH; i++) {
+                const on = i >= thumbAt && i < thumbAt + thumbH;
+                draw.text(x + w - 2, bodyTop + i, on ? "█" : "░", { fg: on ? BRAND : FAINT });
+            }
+        }
+        // footer: open, export shortcuts (when an invoice is parsed), quit - drawn left to right
+        const footerY = bodyTop + viewH + 1;
+        let fx = x + 2;
+        const key = (k, label) => {
+            draw.text(fx, footerY, k, { fg: BRAND });
+            draw.text(fx + k.length + 1, footerY, label, { fg: INK });
+            fx += k.length + 1 + label.length + 2;
+        };
+        key("o", loaded || error ? "open another" : "open");
+        if (canExport) {
+            key("j", "JSON");
+            key("t", "TXT");
+            key("x", "XLSX");
+        }
+        key("q", "quit");
+        if (notice) {
+            draw.text(x + 2, footerY + 1, fit(notice, w - 4), { fg: notice.startsWith("✓") ? OK : ERR });
+        }
+        draw.flush();
+    }
+    function scrollBy(delta) {
+        scroll += delta;
+        render(); // render() clamps scroll to the valid range
+    }
+    function quit() {
+        input.stop();
+        process.stdin.setRawMode(false);
+        screen.showCursor();
+        screen.leave();
+        process.exit(0);
+    }
+    function exportTo(format) {
+        const inv = loaded === null || loaded === void 0 ? void 0 : loaded.read.invoice;
+        if (!inv || !(loaded === null || loaded === void 0 ? void 0 : loaded.read.totals))
+            return;
+        const name = `${inv.number.replace(/[^\w.-]+/g, "_")}.${format === "txt" ? "txt" : format}`;
+        try {
+            writeFileSync(resolve(process.cwd(), name), exportInvoice(inv, loaded.read.totals, format));
+            notice = `✓ wrote ${name}`;
+        }
+        catch (e) {
+            notice = `✗ export failed: ${e.message}`;
+        }
+        render();
+    }
+    function openFlow() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chosen = yield openFileDialog({ screen, draw, input, startDir: process.cwd(), quit });
+            if (chosen) {
+                notice = null;
+                scroll = 0;
+                try {
+                    const bytes = readFileSync(chosen);
+                    const read = readInvoice(bytes);
+                    const pdfa = read.isPdf ? checkPdfA3(bytes) : null;
+                    let rules = null;
+                    if (read.meta.syntax !== "unknown") {
+                        try {
+                            rules = validateInvoiceXml(read.xml, profileFor(read.meta));
+                        }
+                        catch (_a) {
+                            rules = null;
+                        }
+                    }
+                    loaded = { path: chosen, read, pdfa, rules };
+                    error = null;
+                }
+                catch (e) {
+                    error = e.message;
+                    loaded = null;
+                }
+            }
+            render();
+        });
+    }
+    screen.enter();
+    screen.hideCursor();
+    process.stdin.setRawMode(true); // no echo - keys & mouse go to JANO, not the tty
+    input.start();
+    const main = input.pushLayer("main");
+    main.on("key", (key) => {
+        if (key.name === "q" || (key.ctrl && key.name === "c")) {
+            quit();
+            return true;
+        }
+        if (key.name === "o") {
+            void openFlow();
+            return true;
+        }
+        if ((key.name === "j" || key.name === "t" || key.name === "x") && (loaded === null || loaded === void 0 ? void 0 : loaded.read.invoice)) {
+            exportTo(key.name === "j" ? "json" : key.name === "t" ? "txt" : "xlsx");
+            return true;
+        }
+        if (key.name === "up") {
+            scrollBy(-1);
+            return true;
+        }
+        if (key.name === "down") {
+            scrollBy(1);
+            return true;
+        }
+        if (key.name === "pageup") {
+            scrollBy(-pageSize);
+            return true;
+        }
+        if (key.name === "pagedown") {
+            scrollBy(pageSize);
+            return true;
+        }
+        if (key.name === "home") {
+            scrollBy(-Number.MAX_SAFE_INTEGER);
+            return true;
+        }
+        if (key.name === "end") {
+            scrollBy(Number.MAX_SAFE_INTEGER);
+            return true;
+        }
+    });
+    main.on("resize", () => render());
+    main.on("mouse:click", () => true);
+    main.on("mouse:drag", () => true);
+    main.on("mouse:release", () => true);
+    main.on("mouse:scroll", (e) => {
+        if (e.type === "scroll-up")
+            scrollBy(-3);
+        else if (e.type === "scroll-down")
+            scrollBy(3);
+        return true;
+    });
+    render();
+}

package/dist/tui/file-open.d.ts

@@ -0,0 +1,10 @@
+import { type Screen, type Draw, type InputManager } from "@jano-editor/ui";
+interface Deps {
+    screen: Screen;
+    draw: Draw;
+    input: InputManager;
+    startDir: string;
+    quit: () => void;
+}
+export declare function openFileDialog({ screen, draw, input, startDir, quit, }: Deps): Promise<string | null>;
+export {};

package/dist/tui/file-open.js

@@ -0,0 +1,140 @@
+import { readdirSync, statSync } from "node:fs";
+import { dirname, basename, join } from "node:path";
+import { drawList, listMoveUp, listMoveDown, } from "@jano-editor/ui";
+const BRAND = [26, 79, 138];
+const INK = [230, 234, 240];
+const MUTED = [123, 135, 148];
+const FAINT = [80, 85, 95];
+const ROWS = 10; // visible window height; the list scrolls beyond it
+export function openFileDialog({ screen, draw, input, startDir, quit, }) {
+    return new Promise((done) => {
+        let path = startDir.endsWith("/") ? startDir : startDir + "/";
+        let items = [];
+        let state = { selectedIndex: 0, scrollOffset: 0 };
+        const layer = input.pushLayer("open");
+        const refresh = () => {
+            const dir = path.endsWith("/") ? path : dirname(path);
+            const prefix = path.endsWith("/") ? "" : basename(path);
+            // offer ".." to climb out of the folder (only while browsing, not mid-typing, and not at root)
+            const cur = dir.replace(/\/+$/, "") || "/";
+            const parent = dirname(cur);
+            const up = prefix === "" && parent !== cur
+                ? [{ label: "../", value: parent === "/" ? "/" : parent + "/" }]
+                : [];
+            try {
+                const entries = readdirSync(dir, { withFileTypes: true })
+                    .filter((e) => e.name.startsWith(prefix))
+                    .filter((e) => e.isDirectory() || /\.(pdf|xml)$/i.test(e.name))
+                    .sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name))
+                    .map((e) => {
+                    const full = join(dir, e.name);
+                    return e.isDirectory()
+                        ? { label: e.name + "/", value: full + "/" }
+                        : { label: e.name, value: full };
+                });
+                items = [...up, ...entries];
+            }
+            catch (_a) {
+                items = up;
+            }
+            state = { selectedIndex: 0, scrollOffset: 0 };
+        };
+        const render = () => {
+            const cols = screen.width;
+            const w = Math.max(44, Math.min(cols - 2, 72));
+            const x = Math.max(1, Math.floor((cols - w) / 2)); // centre the dialog
+            const y = 2;
+            const avail = w - 11; // keep the text + cursor strictly inside the right border
+            const shown = path.length > avail ? "…" + path.slice(-(avail - 1)) : path;
+            draw.clear();
+            draw.rect(x, y, w, ROWS + 6, { border: "round" });
+            draw.text(x + 2, y, " open invoice ", { fg: BRAND });
+            draw.text(x + 2, y + 1, "path:", { fg: MUTED });
+            draw.text(x + 8, y + 1, shown + "▌", { fg: INK });
+            if (items.length) {
+                drawList(draw, {
+                    x: x + 2,
+                    y: y + 3,
+                    width: w - 4,
+                    height: ROWS,
+                    items,
+                    selectedIndex: state.selectedIndex,
+                    scrollOffset: state.scrollOffset,
+                });
+            }
+            else {
+                draw.text(x + 2, y + 3, "(no matching folders / .pdf / .xml here)", { fg: MUTED });
+            }
+            const pos = items.length ? `${state.selectedIndex + 1}/${items.length}` : "0";
+            draw.text(x + 2, y + ROWS + 4, `↑↓ pick (${pos}) · Tab complete · ⏎ open · Esc cancel`, {
+                fg: FAINT,
+            });
+            draw.flush();
+        };
+        const close = (result) => {
+            input.popLayer(layer);
+            done(result);
+        };
+        const current = () => items[state.selectedIndex];
+        layer.on("key", (key) => {
+            if (key.ctrl && key.name === "c") {
+                quit(); // never returns - restores the tty and exits
+                return true;
+            }
+            if (key.name === "escape" || (key.raw.length === 1 && key.raw[0] === 0x1b)) {
+                close(null);
+            }
+            else if (key.name === "up") {
+                state = listMoveUp(state, items);
+                render();
+            }
+            else if (key.name === "down") {
+                state = listMoveDown(state, items, ROWS);
+                render();
+            }
+            else if (key.name === "tab") {
+                const c = current();
+                if (c) {
+                    path = c.value;
+                    refresh();
+                    render();
+                }
+            }
+            else if (key.name === "enter" || key.name === "return") {
+                const c = current();
+                if (c && c.value.endsWith("/")) {
+                    path = c.value; // descend into the folder (or climb via "../")
+                    refresh();
+                    render();
+                }
+                else if (c) {
+                    close(c.value); // load the file
+                }
+                else {
+                    try {
+                        if (statSync(path).isFile())
+                            close(path);
+                    }
+                    catch (_a) {
+                        /* nothing to open */
+                    }
+                }
+            }
+            else if (key.name === "backspace") {
+                path = path.slice(0, -1);
+                refresh();
+                render();
+            }
+            else if (!key.ctrl && !key.alt && key.name.length === 1) {
+                path += key.name;
+                refresh();
+                render();
+            }
+            return true; // modal swallows everything (Ctrl-C / Esc handled above)
+        });
+        layer.on("mouse:click", () => true);
+        layer.on("mouse:scroll", () => true);
+        refresh();
+        render();
+    });
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@jasy/cli",
+  "version": "1.0.0-alpha.1",
+  "description": "Interactive terminal to validate, read and export ZUGFeRD / XRechnung e-invoices.",
+  "keywords": [
+    "cli",
+    "e-invoice",
+    "tui",
+    "validator",
+    "xrechnung",
+    "zugferd"
+  ],
+  "license": "MIT",
+  "author": "Florian Heuberger",
+  "bin": {
+    "jasy": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "assets"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "dependencies": {
+    "@jano-editor/ui": "1.0.0-alpha.8",
+    "saxon-js": "^2.6.0",
+    "@jasy/zugferd": "1.0.0-alpha.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.3",
+    "tsx": "^4.19.2",
+    "xslt3": "^2.7.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "watch": "tsx watch src/index.ts",
+    "typecheck": "tsc --noEmit"
+  }
+}