@st-gr/abap-adt-skill 1.0.0

package/dist/commands/systems.js

@@ -0,0 +1,514 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectionKey = connectionKey;
+exports.saveConnection = saveConnection;
+exports.loadConnection = loadConnection;
+exports.loadConnectionByKey = loadConnectionByKey;
+exports.setActiveConnection = setActiveConnection;
+exports.listConnections = listConnections;
+exports.systemsListCommand = systemsListCommand;
+exports.systemsSearchCommand = systemsSearchCommand;
+exports.systemsStatusCommand = systemsStatusCommand;
+exports.systemsSwitchCommand = systemsSwitchCommand;
+exports.systemsRemoveCommand = systemsRemoveCommand;
+exports.systemsConnectCommand = systemsConnectCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const abap_adt_api_patched_1 = require("@st-gr/abap-adt-api-patched");
+const landscape_1 = require("../util/landscape");
+const network_1 = require("../util/network");
+const credentials_1 = require("../util/credentials");
+function getConnectionFilePath() {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    return path.join(home, ".sap", "adt-connection.json");
+}
+/** Decrypt a connection value — handles both encrypted (string) and plain (object) formats */
+function decryptConnection(value) {
+    if (typeof value === "object")
+        return value; // legacy unencrypted
+    if (!(0, credentials_1.isWindows)())
+        return null; // can't decrypt on non-Windows
+    try {
+        return JSON.parse((0, credentials_1.decryptDPAPI)(value));
+    }
+    catch (_a) {
+        return null;
+    }
+}
+/** Encrypt a connection for storage (returns DPAPI blob on Windows, plain object otherwise) */
+function encryptConnection(conn) {
+    if (!(0, credentials_1.isWindows)())
+        return conn; // no DPAPI — store plaintext
+    try {
+        return (0, credentials_1.encryptDPAPI)(JSON.stringify(conn));
+    }
+    catch (_a) {
+        return conn; // fallback to plaintext
+    }
+}
+function loadStore() {
+    try {
+        const raw = JSON.parse(fs.readFileSync(getConnectionFilePath(), "utf-8"));
+        // Migrate old single-connection format (pre-multi-connection)
+        if (raw.url && !raw.connections) {
+            const conn = raw;
+            const key = guessKeyFromUrl(conn);
+            const store = { active: key, connections: { [key]: encryptConnection(conn) } };
+            saveStore(store); // persist migration
+            return store;
+        }
+        // Migrate any plain-object entries to encrypted
+        const store = raw;
+        let migrated = false;
+        for (const [key, value] of Object.entries(store.connections)) {
+            if (typeof value === "object") {
+                store.connections[key] = encryptConnection(value);
+                migrated = true;
+            }
+        }
+        if (migrated)
+            saveStore(store);
+        return store;
+    }
+    catch (_a) {
+        return { active: "", connections: {} };
+    }
+}
+function saveStore(store) {
+    const filePath = getConnectionFilePath();
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(store, null, 2));
+}
+function guessKeyFromUrl(conn) {
+    const host = new URL(conn.url).hostname.split(".")[0].toUpperCase();
+    return conn.client ? `${host}/${conn.client}` : host;
+}
+/** Make a connection key from SID + client */
+function connectionKey(sid, client) {
+    return client ? `${sid.toUpperCase()}/${client}` : sid.toUpperCase();
+}
+/** Save a connection under a key and set it as active */
+function saveConnection(key, conn) {
+    const store = loadStore();
+    store.connections[key] = encryptConnection(conn);
+    store.active = key;
+    saveStore(store);
+}
+/** Load the active connection */
+function loadConnection() {
+    const store = loadStore();
+    if (!store.active)
+        return null;
+    const value = store.connections[store.active];
+    if (!value)
+        return null;
+    return decryptConnection(value);
+}
+/** Load a specific connection by key */
+function loadConnectionByKey(key) {
+    const store = loadStore();
+    const value = store.connections[key];
+    if (!value)
+        return null;
+    return decryptConnection(value);
+}
+/** Set a different connection as active */
+function setActiveConnection(key) {
+    const store = loadStore();
+    if (!store.connections[key])
+        return false;
+    store.active = key;
+    saveStore(store);
+    return true;
+}
+/** List all stored connections (decrypts each entry) */
+function listConnections() {
+    const store = loadStore();
+    return Object.entries(store.connections).map(([key, value]) => ({
+        key,
+        conn: decryptConnection(value),
+        active: key === store.active,
+    }));
+}
+function detectShell() {
+    const shell = (process.env.SHELL || process.env.ComSpec || "").toLowerCase();
+    if (shell.includes("bash") || shell.includes("zsh") || process.env.MSYSTEM)
+        return "bash";
+    if (shell.includes("powershell") || shell.includes("pwsh") || process.env.PSModulePath)
+        return "powershell";
+    return "cmd";
+}
+function envSetSyntax(shell, name, value) {
+    switch (shell) {
+        case "bash": return `export ${name}="${value}"`;
+        case "powershell": return `$env:${name} = "${value}"`;
+        case "cmd": return `set ${name}=${value}`;
+    }
+}
+function padRight(s, len) {
+    return s.length >= len ? s.slice(0, len) : s + " ".repeat(len - s.length);
+}
+function printTable(systems, showUrls) {
+    if (systems.length === 0) {
+        console.log("No systems found.");
+        return;
+    }
+    if (showUrls) {
+        const hSid = "SID", hServer = "Server", hHttp = "HTTP URL", hName = "Name";
+        const wSid = Math.max(hSid.length, ...systems.map(s => s.sid.length));
+        const wServer = Math.max(hServer.length, ...systems.map(s => s.server.length));
+        const wHttp = Math.max(hHttp.length, ...systems.map(s => s.httpUrl.length));
+        console.log(`${padRight(hSid, wSid)} | ${padRight(hServer, wServer)} | ${padRight(hHttp, wHttp)} | ${hName}`);
+        console.log(`${"-".repeat(wSid)}-+-${"-".repeat(wServer)}-+-${"-".repeat(wHttp)}-+-${"-".repeat(40)}`);
+        for (const s of systems) {
+            console.log(`${padRight(s.sid, wSid)} | ${padRight(s.server, wServer)} | ${padRight(s.httpUrl, wHttp)} | ${s.name}`);
+        }
+    }
+    else {
+        const hSid = "SID", hServer = "Server", hName = "Name";
+        const wSid = Math.max(hSid.length, ...systems.map(s => s.sid.length));
+        const wServer = Math.max(hServer.length, ...systems.map(s => s.server.length));
+        console.log(`${padRight(hSid, wSid)} | ${padRight(hServer, wServer)} | ${hName}`);
+        console.log(`${"-".repeat(wSid)}-+-${"-".repeat(wServer)}-+-${"-".repeat(40)}`);
+        for (const s of systems) {
+            console.log(`${padRight(s.sid, wSid)} | ${padRight(s.server, wServer)} | ${s.name}`);
+        }
+    }
+}
+async function systemsListCommand(options) {
+    const file = (0, landscape_1.findLandscapeFile)(options.landscape);
+    const systems = (0, landscape_1.parseLandscape)(file);
+    console.log(`Landscape: ${file} (${systems.length} systems)\n`);
+    printTable(systems, !!options.urls);
+}
+async function systemsSearchCommand(query, options) {
+    const file = (0, landscape_1.findLandscapeFile)(options.landscape);
+    const systems = (0, landscape_1.parseLandscape)(file);
+    const q = query.toUpperCase();
+    const filtered = systems.filter(s => s.sid.toUpperCase().includes(q) || s.name.toUpperCase().includes(q));
+    printTable(filtered, true);
+}
+function systemsStatusCommand() {
+    var _a;
+    const all = listConnections();
+    if (all.length === 0) {
+        console.log("No stored connections.");
+        console.log("Run 'abap-adt systems connect <SID> [client]' to connect.");
+        return;
+    }
+    // Show all connections summary
+    console.log("Stored connections:\n");
+    for (const { key, conn, active } of all) {
+        const marker = active ? " *" : "  ";
+        if (!conn) {
+            console.log(`${marker} ${padRight(key, 12)} (decrypt failed)`);
+            continue;
+        }
+        const proto = conn.url.startsWith("https://") ? "HTTPS" : "HTTP";
+        const cred = conn.encryptedPassword ? "DPAPI" : "no pwd";
+        console.log(`${marker} ${padRight(key, 12)} ${padRight(proto, 5)} ${padRight(conn.user || "-", 12)} ${padRight(cred, 7)} ${conn.url}`);
+    }
+    // Show active connection details
+    const conn = loadConnection();
+    if (conn) {
+        const isHttps = conn.url.startsWith("https://");
+        console.log(`\nActive: ${(_a = all.find(c => c.active)) === null || _a === void 0 ? void 0 : _a.key}`);
+        console.log(`URL:         ${conn.url}`);
+        console.log(`Client:      ${conn.client || "(default)"}`);
+        console.log(`Language:    ${conn.language}`);
+        console.log(`HTTPS:       ${isHttps ? "yes" : "no"}`);
+        console.log(`Self-signed: ${conn.allowSelfSigned ? "yes" : "no"}`);
+        console.log(`User:        ${conn.user || "(not stored — defaults to OS username)"}`);
+        console.log(`Password:    ${conn.encryptedPassword ? "stored (DPAPI-encrypted)" : "not stored (set ADT_PASS)"}`);
+    }
+}
+function systemsSwitchCommand(key) {
+    // Try exact match first
+    if (setActiveConnection(key)) {
+        console.log(`Switched to ${key}`);
+        return;
+    }
+    // Try case-insensitive / partial match (e.g. "se1" matches "SE1/600")
+    const all = listConnections();
+    const upper = key.toUpperCase();
+    const matches = all.filter(c => c.key.toUpperCase().startsWith(upper));
+    if (matches.length === 1) {
+        setActiveConnection(matches[0].key);
+        console.log(`Switched to ${matches[0].key}`);
+    }
+    else if (matches.length > 1) {
+        console.error(`Ambiguous key '${key}'. Matches:`);
+        for (const m of matches) {
+            console.error(`  ${m.key}`);
+        }
+        process.exit(1);
+    }
+    else {
+        console.error(`No connection found for '${key}'.`);
+        console.error(`Stored: ${all.map(c => c.key).join(", ") || "(none)"}`);
+        process.exit(1);
+    }
+}
+function systemsRemoveCommand(key) {
+    const store = loadStore();
+    // Try exact match
+    let matchedKey = Object.keys(store.connections).find(k => k === key);
+    // Try case-insensitive
+    if (!matchedKey) {
+        const upper = key.toUpperCase();
+        matchedKey = Object.keys(store.connections).find(k => k.toUpperCase() === upper);
+    }
+    if (!matchedKey) {
+        console.error(`No connection found for '${key}'.`);
+        process.exit(1);
+    }
+    delete store.connections[matchedKey];
+    if (store.active === matchedKey) {
+        const remaining = Object.keys(store.connections);
+        store.active = remaining.length > 0 ? remaining[0] : "";
+    }
+    saveStore(store);
+    console.log(`Removed ${matchedKey}`);
+}
+async function systemsConnectCommand(sid, clientArg, options) {
+    const file = (0, landscape_1.findLandscapeFile)(options.landscape);
+    const systems = (0, landscape_1.parseLandscape)(file);
+    const matches = systems.filter(s => s.sid.toUpperCase() === sid.toUpperCase());
+    if (matches.length === 0) {
+        console.error(`No system found with SID: ${sid}`);
+        console.error(`Use 'systems list' to see available systems.`);
+        process.exit(1);
+    }
+    let selected;
+    if (matches.length === 1) {
+        selected = matches[0];
+    }
+    else {
+        // Multiple entries — pick first by default, show options to stderr
+        console.error(`Multiple entries for ${sid.toUpperCase()}:`);
+        for (let i = 0; i < matches.length; i++) {
+            console.error(`  ${i + 1}. ${matches[i].name} — ${matches[i].server}`);
+        }
+        if (process.stdin.isTTY) {
+            const choice = await prompt(`Select [1]: `);
+            const idx = parseInt(choice || "1", 10) - 1;
+            if (idx < 0 || idx >= matches.length) {
+                console.error("Invalid selection.");
+                process.exit(1);
+            }
+            selected = matches[idx];
+        }
+        else {
+            console.error(`Using first entry (non-interactive mode).`);
+            selected = matches[0];
+        }
+    }
+    // Resolve short hostname to FQDN via DNS
+    const fqdn = await (0, landscape_1.resolveHostnameFQDN)(selected.hostname);
+    // VPN safety: verify hostname resolves to a private IP
+    try {
+        await (0, network_1.assertPrivateHost)(fqdn);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Gather credentials first (needed for HTTPURLLOC lookup)
+    const client = clientArg || "";
+    const defaultUser = (process.env.USERNAME || process.env.USER || "").toUpperCase();
+    let user = options.user || "";
+    let password = options.password || process.env.ADT_PASS || "";
+    const shell = detectShell();
+    if (process.stdin.isTTY && !user) {
+        user = await prompt(`Username [${defaultUser}]: `) || defaultUser;
+    }
+    else if (!user) {
+        user = defaultUser;
+    }
+    if (process.stdin.isTTY && !password) {
+        password = await promptHidden("Password: ");
+    }
+    if (!password) {
+        console.error("Error: No password. Set ADT_PASS in your shell before launching Claude:");
+        console.error(`  ${envSetSyntax(shell, "ADT_PASS", "<your_password>")}`);
+        process.exit(1);
+    }
+    // Connect via HTTP and discover HTTPS from HTTPURLLOC
+    const httpPort = `80${selected.instanceNr}`;
+    const httpUrl = `http://${fqdn}:${httpPort}`;
+    let url = httpUrl;
+    let useHttps = false;
+    if (!options.noHttps) {
+        console.error(`Connecting via HTTP to discover HTTPS configuration...`);
+        try {
+            const adtClient = new abap_adt_api_patched_1.ADTClient(httpUrl, user, password, client, "EN", (0, abap_adt_api_patched_1.createSSLConfig)(true));
+            await adtClient.login();
+            // Query HTTPURLLOC for official HTTPS endpoint
+            const result = await adtClient.tableContents("HTTPURLLOC", 10);
+            const httpsRow = result.values.find((row) => String(row.PROTOCOL || "").trim().toUpperCase() === "HTTPS");
+            if (httpsRow) {
+                const httpsHost = String(httpsRow.HOST || "").trim().toLowerCase();
+                const httpsPort = parseInt(String(httpsRow.PORT || "0").trim(), 10);
+                if (httpsHost && httpsPort > 0) {
+                    console.error(`HTTPURLLOC: HTTPS at ${httpsHost}:${httpsPort} — probing...`);
+                    if (await (0, network_1.probePort)(httpsHost, httpsPort)) {
+                        url = httpsPort === 443 ? `https://${httpsHost}` : `https://${httpsHost}:${httpsPort}`;
+                        useHttps = true;
+                        console.error(`HTTPS verified — using secure connection`);
+                    }
+                    else {
+                        console.error(`HTTPS port ${httpsPort} not reachable — using HTTP`);
+                    }
+                }
+            }
+            else {
+                console.error(`No HTTPS configured in HTTPURLLOC — using HTTP`);
+            }
+        }
+        catch (err) {
+            const is401 = String(err.message).includes("401");
+            if (is401) {
+                console.error(`Authentication failed (401) — check password for ${sid.toUpperCase()}`);
+                console.error(`HTTPS discovery skipped (cannot query HTTPURLLOC without valid credentials)`);
+                console.error(`Using HTTP — re-run 'systems connect' with correct password to discover HTTPS`);
+            }
+            else {
+                console.error(`HTTPURLLOC lookup failed: ${err.message}`);
+                // TCP probe fallback — only for non-auth errors (timeout, connection refused)
+                // Auth failures mean we can't verify which system owns the HTTPS port
+                console.error(`Probing HTTPS ports on ${fqdn}...`);
+                for (const port of [443, 8443]) {
+                    if (await (0, network_1.probePort)(fqdn, port)) {
+                        url = port === 443 ? `https://${fqdn}` : `https://${fqdn}:${port}`;
+                        useHttps = true;
+                        console.error(`HTTPS available on port ${port}`);
+                        break;
+                    }
+                }
+                if (!useHttps) {
+                    console.error(`No HTTPS found — using HTTP`);
+                }
+            }
+        }
+    }
+    else {
+        console.error(`Using HTTP (--no-https specified)`);
+    }
+    // Save connection to ~/.sap/adt-connection.json
+    const conn = {
+        url,
+        client,
+        language: "EN",
+        allowSelfSigned: useHttps,
+        user,
+    };
+    // Encrypt password with DPAPI on Windows
+    if ((0, credentials_1.isWindows)()) {
+        try {
+            conn.encryptedPassword = (0, credentials_1.encryptDPAPI)(password);
+            console.error(`Password encrypted with Windows DPAPI`);
+        }
+        catch (err) {
+            console.error(`Warning: DPAPI encryption failed: ${err.message}`);
+            console.error(`Password not stored — set ADT_PASS manually for subsequent commands`);
+        }
+    }
+    else {
+        console.error(`Warning: DPAPI not available (non-Windows). Password not stored.`);
+    }
+    const key = connectionKey(selected.sid, client);
+    saveConnection(key, conn);
+    console.log(`Connected: ${selected.sid} client ${client || "(default)"} @ ${url}`);
+    console.log(`Connection saved to ~/.sap/adt-connection.json`);
+    if (conn.encryptedPassword) {
+        console.log(`Credentials: stored (DPAPI-encrypted, user: ${user})`);
+    }
+    else {
+        console.log(`\nCredentials (set in your shell before using other commands):`);
+        if (user !== defaultUser) {
+            console.log(`  ${envSetSyntax(shell, "ADT_USER", user)}`);
+        }
+        console.log(`  ${envSetSyntax(shell, "ADT_PASS", "<your_password>")}`);
+    }
+}
+function prompt(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise(resolve => {
+        rl.question(question, answer => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function promptHidden(question) {
+    return new Promise(resolve => {
+        process.stderr.write(question);
+        const rl = readline.createInterface({ input: process.stdin, terminal: false });
+        // Attempt to hide input on TTY
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        let input = "";
+        const onData = (ch) => {
+            const c = ch.toString();
+            if (c === "\n" || c === "\r" || c === "\u0004") {
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(false);
+                }
+                process.stdin.removeListener("data", onData);
+                process.stderr.write("\n");
+                rl.close();
+                resolve(input);
+            }
+            else if (c === "\u0003") {
+                // Ctrl+C
+                process.exit(1);
+            }
+            else if (c === "\u007f" || c === "\b") {
+                // Backspace
+                input = input.slice(0, -1);
+            }
+            else {
+                input += c;
+            }
+        };
+        process.stdin.on("data", onData);
+        process.stdin.resume();
+    });
+}

package/dist/commands/table.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableCommand = tableCommand;
+exports.sqlCommand = sqlCommand;
+const client_1 = require("../client");
+const formatter_1 = require("../util/formatter");
+async function tableCommand(tableName, options) {
+    const client = await (0, client_1.getStatelessClient)();
+    const maxRows = options.rows ? parseInt(options.rows, 10) : 100;
+    const result = await client.tableContents(tableName.toUpperCase(), maxRows);
+    if (options.json) {
+        (0, formatter_1.output)(result, true);
+        return;
+    }
+    if (!result.columns || result.columns.length === 0) {
+        console.log("No data returned.");
+        return;
+    }
+    console.log(`Table: ${tableName.toUpperCase()}`);
+    console.log(`Rows returned: ${result.values.length}`);
+    console.log();
+    const cols = result.columns.map(c => c.name);
+    const rows = result.values.map((row) => {
+        var _a;
+        const r = {};
+        for (const col of cols) {
+            r[col] = String((_a = row[col]) !== null && _a !== void 0 ? _a : "");
+        }
+        return r;
+    });
+    if (rows.length > 0) {
+        console.log((0, formatter_1.formatTable)(rows, cols));
+    }
+    else {
+        console.log("(empty)");
+    }
+}
+async function sqlCommand(query, options) {
+    const client = await (0, client_1.getStatelessClient)();
+    const maxRows = options.rows ? parseInt(options.rows, 10) : 100;
+    const result = await client.runQuery(query, maxRows);
+    if (options.json) {
+        (0, formatter_1.output)(result, true);
+        return;
+    }
+    if (!result.columns || result.columns.length === 0) {
+        console.log("No data returned.");
+        return;
+    }
+    const cols = result.columns.map(c => c.name);
+    const rows = result.values.map((row) => {
+        var _a;
+        const r = {};
+        for (const col of cols) {
+            r[col] = String((_a = row[col]) !== null && _a !== void 0 ? _a : "");
+        }
+        return r;
+    });
+    if (rows.length > 0) {
+        console.log((0, formatter_1.formatTable)(rows, cols));
+    }
+    else {
+        console.log("(empty)");
+    }
+}

package/dist/commands/test.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testCommand = testCommand;
+const client_1 = require("../client");
+const formatter_1 = require("../util/formatter");
+async function testCommand(objectUrl, options) {
+    const client = await (0, client_1.getClient)();
+    const flags = {
+        harmless: true,
+        dangerous: false,
+        critical: false,
+        short: true,
+        medium: false,
+        long: false
+    };
+    // Parse risk level
+    if (options.risk) {
+        const risks = options.risk.split(",");
+        flags.harmless = risks.includes("harmless");
+        flags.dangerous = risks.includes("dangerous");
+        flags.critical = risks.includes("critical");
+        // If user specifies a level, include all levels up to it
+        if (risks.includes("critical")) {
+            flags.harmless = true;
+            flags.dangerous = true;
+            flags.critical = true;
+        }
+        else if (risks.includes("dangerous")) {
+            flags.harmless = true;
+            flags.dangerous = true;
+        }
+    }
+    // Parse duration
+    if (options.duration) {
+        const durations = options.duration.split(",");
+        flags.short = durations.includes("short");
+        flags.medium = durations.includes("medium");
+        flags.long = durations.includes("long");
+        if (durations.includes("long")) {
+            flags.short = true;
+            flags.medium = true;
+            flags.long = true;
+        }
+        else if (durations.includes("medium")) {
+            flags.short = true;
+            flags.medium = true;
+        }
+    }
+    const classes = await client.unitTestRun(objectUrl, flags);
+    if (options.json) {
+        (0, formatter_1.output)(classes, true);
+        return;
+    }
+    if (classes.length === 0) {
+        console.log("No test classes found.");
+        return;
+    }
+    let totalMethods = 0;
+    let passedMethods = 0;
+    let failedMethods = 0;
+    for (const cls of classes) {
+        console.log(`\nTest Class: ${cls["adtcore:name"]}`);
+        console.log(`  Risk: ${cls.riskLevel}, Duration: ${cls.durationCategory}`);
+        if (cls.alerts && cls.alerts.length > 0) {
+            for (const alert of cls.alerts) {
+                console.log(`  [${alert.severity}] ${alert.kind}: ${alert.title}`);
+                for (const detail of alert.details) {
+                    console.log(`    ${detail}`);
+                }
+            }
+        }
+        for (const method of cls.testmethods) {
+            totalMethods++;
+            const hasAlerts = method.alerts && method.alerts.length > 0;
+            const status = hasAlerts ? "FAILED" : "PASSED";
+            if (hasAlerts)
+                failedMethods++;
+            else
+                passedMethods++;
+            console.log(`  ${status} ${method["adtcore:name"]} (${method.executionTime}ms)`);
+            if (hasAlerts) {
+                for (const alert of method.alerts) {
+                    console.log(`    [${alert.severity}] ${alert.kind}: ${alert.title}`);
+                    for (const detail of alert.details) {
+                        console.log(`      ${detail}`);
+                    }
+                    if (alert.stack && alert.stack.length > 0) {
+                        console.log(`    Stack:`);
+                        for (const entry of alert.stack) {
+                            console.log(`      ${entry["adtcore:name"]} ${entry["adtcore:description"]}`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    console.log(`\n--- Summary: ${totalMethods} tests, ${passedMethods} passed, ${failedMethods} failed ---`);
+    if (failedMethods > 0)
+        process.exit(1);
+}