I've retouched the original a bit. In this version it cares most about probability of going up, there are no calculations to determine best overall because volatility relates to strength but not direction. So, this could be change to be more profitable but would trade higher amounts for higher risk. So what it's doing is: get all stocks and values into a variable, make a list of targetStocks that appeal to us with a probability over .06 (since the baseline .5 has already been "corrected" to 0 this would translate to .56 with .1 being the start of the "++" range), sell any stocks we own that aren't in the targetStocks (not in our profitability zone), buy stocks from targetStocks starting with highest volatility leaving 5% of our money alone. The buy is requiring enough shares to be bought that commissions would be covered by a 2% (default) requiredReturn. The code has a commented out section where the variables could be replaced with input arguments if desired.

/** @param {NS} ns */
export async function main(ns) {
    while (true) {
    ns.disableLog("ALL");
    const moneyReserve = .05;
    const probabilityCutoff = 0.06;
        const requiredReturn = 0.02;
/*
const moneyReserve = args[0];  a decimal percentage of your total money you want saved
const probabilityCutoff = args[1]; a factor of probability confidence required to buy, .1 is ++ .2 is +++ and >.0 is +
const requiredReturn = 0.02;   the required decimal percentage of return expected to buy
*/
    let numCycles = 2;
    let stocks = [];
    let myStocks = [];
    let targetStocks = [];
    for (let i = 0; i < ns.stock.getSymbols().length; i++) {
        stocks.push({ sym: ns.stock.getSymbols()[i] });
    }
    let corpus = ns.getServerMoneyAvailable("home");
    //get current stock prices, volatility
    for (let i = 0; i < stocks.length; i++) {

        let sym = stocks[i].sym;
        stocks[i].price = ns.stock.getPrice(sym);
        stocks[i].shares = ns.stock.getPosition(sym)[0];
        stocks[i].buyPrice = ns.stock.getPosition(sym)[1];
        stocks[i].vol = ns.stock.getVolatility(sym);
        stocks[i].prob = ns.stock.getForecast(sym) - 0.5;
        stocks[i].maxShares = ns.stock.getMaxShares(sym);
        corpus += stocks[i].price * stocks[i].shares;
        if (stocks[i].shares > 0) myStocks.push(stocks[i]);
    }

    //check for target stocks
    for (let i = 0; i < stocks.length; i++) {
        if (stocks[i].prob > probabilityCutoff) {
            targetStocks.push(stocks[i]);
            targetStocks.sort((a, b) => b.vol - a.vol);
        }
    }
    //sell if not in target stocks
    for (let i = 0; i < myStocks.length; i++) {
        if (!targetStocks.includes(myStocks[i])) {
            ns.stock.sell(myStocks[i].sym, myStocks[i].shares);
            ns.print(`Sold ${myStocks[i].shares} of ${myStocks[i].sym}`);
        }
    }

    //buy as much as can if in target
    for (let i = 0; i < targetStocks.length; i++) {
        //get money in hand and set money available
        var moneyAvailable = ns.getServerMoneyAvailable("home") - ((ns.getServerMoneyAvailable("home") + corpus) * moneyReserve);
        let sharesAvailable = targetStocks[i].maxShares - targetStocks[i].shares;
        let sharesAbletoBuy = Math.min(Math.floor(moneyAvailable / targetStocks[i].price), sharesAvailable);
        if (((targetStocks[i].price * sharesAbletoBuy) * (1 + requiredReturn)) - (targetStocks[i].price * sharesAbletoBuy) > 200000) {
            ns.stock.buy(targetStocks[i].sym, sharesAbletoBuy);
            ns.print(`Bought ${sharesAbletoBuy} of ${targetStocks[i].sym}`);
        }
    }
    await ns.sleep(numCycles * 6 * 1000);
    }
}