@fraziym/axoniz 0.1.0

package/dist/core/runner.js

@@ -0,0 +1,671 @@
+/**
+ * AXONIZ-ZERO — Runner
+ * Port of axoniz/core/runner.py.
+ *
+ * A hand-rolled argument parser is used instead of a framework so that the
+ * exact Python semantics are preserved: free-form positional arguments that may
+ * also be subcommands (`config`, `model`, `memory`, `palace`, `setup`).
+ */
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import process from "node:process";
+import { loadConfig, loadConfigWithAutodetect, saveConfig, showConfig, resetConfig, MODELS_DIR, AXONIZ_HOME, activeProvider, } from "./config.js";
+import { debug, error as logError, getLogger } from "./debug.js";
+export const VERSION = "1.0.0";
+/* ── Colour ───────────────────────────────────────────────────────────────── */
+function c(code) {
+    if (process.env.NO_COLOR || !process.stdout.isTTY)
+        return "";
+    return `\u001b[${code}m`;
+}
+const R = c("0");
+const B = c("1");
+const DG = c("90");
+const GR = c("37");
+const BL = c("94");
+const GB = c("92");
+const YL = c("93");
+const RD = c("91");
+const WH = c("97");
+const CY = c("96");
+const PURPLE = c("95");
+export class C {
+    static RESET = R;
+    static BOLD = B;
+    static GRAY = DG;
+    static DGRAY = DG;
+    static WHITE = WH;
+    static BLUE = BL;
+    static GREEN = GB;
+    static YELLOW = YL;
+    static RED = RD;
+    static CYAN = CY;
+    static PURPLE = PURPLE;
+}
+export function printBanner(model = "", backend = "") {
+    console.log();
+    console.log(`  ${PURPLE}${B}FRAZIYM AI${R}  ${DG}v${VERSION}${R}`);
+    console.log(`  ${DG}local ai agent \u00b7 ${backend} \u00b7 ${model || "auto"}${R}`);
+    console.log();
+}
+export function kv(key, val) {
+    console.log(`  ${DG}${key.padEnd(18)}${R}${GR}${String(val)}${R}`);
+}
+export function section(title) {
+    console.log(`\n  ${DG}${title.toUpperCase()}${R}\n  ${DG}${"-".repeat(Math.min(title.length + 4, 60))}${R}`);
+}
+export function makeDefaultArgs() {
+    return {
+        positional: [],
+        lc: false,
+        cli: false,
+        web: false,
+        goal: null,
+        pipe: false,
+        provider: null,
+        model_name: null,
+        model_path: null,
+        base_url: null,
+        n_gpu_layers: null,
+        max_steps: null,
+        temperature: null,
+        max_tokens: null,
+        n_ctx: null,
+        workspace: null,
+        port: 7860,
+        help: false,
+        version: false,
+    };
+}
+const PROVIDERS = ["llamacpp", "llamacpp_server", "lmstudio", "ollama", "openai"];
+/** Parse argv (already sliced past `node script`). */
+export function parseArgs(argv) {
+    const a = makeDefaultArgs();
+    const takesValue = new Set([
+        "--goal",
+        "--provider",
+        "--model",
+        "--model-path",
+        "--url",
+        "--gpu-layers",
+        "--steps",
+        "--temp",
+        "--tokens",
+        "--ctx",
+        "--workspace",
+        "--port",
+    ]);
+    const num = (v) => {
+        if (v === undefined)
+            return null;
+        const n = Number(v);
+        return Number.isFinite(n) ? n : null;
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        // Support --key=value form.
+        let key = arg;
+        let inlineValue;
+        if (arg.startsWith("--") && arg.includes("=")) {
+            const idx = arg.indexOf("=");
+            key = arg.slice(0, idx);
+            inlineValue = arg.slice(idx + 1);
+        }
+        const value = () => {
+            if (inlineValue !== undefined)
+                return inlineValue;
+            if (takesValue.has(key) && i + 1 < argv.length) {
+                i += 1;
+                return argv[i];
+            }
+            return undefined;
+        };
+        switch (key) {
+            case "--lc":
+                a.lc = true;
+                break;
+            case "--cli":
+                a.cli = true;
+                break;
+            case "--web":
+            case "-w":
+                a.web = true;
+                break;
+            case "--pipe":
+                a.pipe = true;
+                break;
+            case "--goal":
+                a.goal = value() ?? null;
+                break;
+            case "--provider": {
+                const p = value();
+                if (p && !PROVIDERS.includes(p)) {
+                    process.stderr.write(`argument --provider: invalid choice: '${p}' (choose from ${PROVIDERS.join(", ")})\n`);
+                    process.exit(2);
+                }
+                a.provider = p ?? null;
+                break;
+            }
+            case "--model":
+                a.model_name = value() ?? null;
+                break;
+            case "--model-path":
+                a.model_path = value() ?? null;
+                break;
+            case "--url":
+                a.base_url = value() ?? null;
+                break;
+            case "--gpu-layers":
+                a.n_gpu_layers = num(value());
+                break;
+            case "--steps":
+                a.max_steps = num(value());
+                break;
+            case "--temp":
+                a.temperature = num(value());
+                break;
+            case "--tokens":
+                a.max_tokens = num(value());
+                break;
+            case "--ctx":
+                a.n_ctx = num(value());
+                break;
+            case "--workspace":
+                a.workspace = value() ?? null;
+                break;
+            case "--port":
+                a.port = num(value()) ?? 7860;
+                break;
+            case "--help":
+            case "-h":
+                a.help = true;
+                break;
+            case "--version":
+                a.version = true;
+                break;
+            default:
+                if (arg.startsWith("-") && arg !== "-") {
+                    process.stderr.write(`unrecognized argument: ${arg}\n`);
+                    process.exit(2);
+                }
+                a.positional.push(arg);
+                break;
+        }
+    }
+    return a;
+}
+/* ── Overrides ────────────────────────────────────────────────────────────── */
+export function overridesFromArgs(args) {
+    const ov = {};
+    const keys = [
+        "model_name",
+        "model_path",
+        "base_url",
+        "max_steps",
+        "temperature",
+        "max_tokens",
+        "n_ctx",
+        "workspace",
+        "n_gpu_layers",
+    ];
+    for (const k of keys) {
+        const v = args[k];
+        if (v !== null && v !== undefined)
+            ov[k] = v;
+    }
+    // Only override the provider when explicitly set on the CLI.
+    if (args.provider) {
+        ov.provider = args.provider;
+        ov.backend = args.provider;
+    }
+    return ov;
+}
+/* ── Help ─────────────────────────────────────────────────────────────────── */
+export const HELP = `
+  ${WH}${B}AXONIZ-ZERO${R}  ${DG}v${VERSION}  \u2014 local AI agent${R}
+
+  ${B}MODES${R}
+    ${BL}--web${R}           Launch web UI at localhost:7860
+    ${BL}--lc${R}            Interactive REPL
+    ${BL}--cli${R}           One-shot task then exit
+    ${BL}--goal "..."${R}    Autonomous goal mode
+    ${BL}--pipe${R}          Read task from stdin
+
+  ${B}BACKEND${R}
+    ${BL}--provider <p>${R}   Backend: llamacpp, llamacpp_server, lmstudio, ollama, openai
+    ${BL}--model-path <p>${R}  Path to .gguf model (llamacpp only)
+    ${BL}--url <url>${R}       Base URL for server backends
+    ${BL}--gpu-layers <n>${R}  GPU layers (llamacpp only)
+    ${BL}--ctx <n>${R}         Context window (llamacpp, default 32768)
+    ${BL}--temp 0.2${R}       Temperature
+    ${BL}--tokens 4096${R}    Max output tokens
+
+  ${B}SUBCOMMANDS${R}
+    ${BL}axoniz config show${R}     Show config
+    ${BL}axoniz config set k=v${R}  Set config value
+    ${BL}axoniz model list${R}      List models
+    ${BL}axoniz model use <n>${R}   Switch model
+    ${BL}axoniz memory${R}          Show memory
+    ${BL}axoniz palace${R}          Show palace status
+    ${BL}axoniz health${R}          System health report
+`;
+/* ── Runner ───────────────────────────────────────────────────────────────── */
+export class Runner {
+    cfg;
+    constructor() {
+        this.cfg = loadConfig();
+    }
+    async buildAgent(overrides = {}) {
+        const cfg = loadConfigWithAutodetect();
+        const clean = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== null && v !== undefined));
+        Object.assign(cfg, clean);
+        if (clean.model_path)
+            cfg.model_name = path.basename(String(clean.model_path));
+        // Default to llamacpp only when no provider is configured at all.
+        const active = cfg.provider ?? cfg.backend ?? cfg.llm?.active_provider;
+        if (!active) {
+            cfg.provider = "llamacpp";
+            cfg.backend = "llamacpp";
+        }
+        const { Agent } = await import("./agent.js");
+        return new Agent(cfg);
+    }
+    async checkBackend(agent) {
+        await agent.health();
+        return true;
+    }
+}
+/* ── Interactive model selection ──────────────────────────────────────────── */
+async function interactiveModelSelect() {
+    console.log(`\n  ${WH}${B}SOVEREIGN VAULT SCAN${R}`);
+    console.log(`  ${DG}Scanning for GGUF models in ${MODELS_DIR}...${R}\n`);
+    const found = [];
+    collectGguf(MODELS_DIR, found, 0);
+    if (found.length === 0) {
+        console.log(`  ${RD}[-] No GGUF models found in vault.${R}`);
+        console.log(`  ${DG}HINT: Place models in ${MODELS_DIR} or use 'axoniz model download'${R}\n`);
+        return null;
+    }
+    found.forEach((p, i) => {
+        const name = path.basename(p);
+        let sizeGb = 0;
+        try {
+            sizeGb = fs.statSync(p).size / 1024 ** 3;
+        }
+        catch {
+            /* ignore */
+        }
+        console.log(`  ${BL}[${i + 1}]${R}  ${WH}${name.padEnd(40)}${R}  ${DG}${sizeGb.toFixed(1)} GB${R}`);
+    });
+    console.log(`\n  ${DG}Enter number to select or path to a different GGUF:${R}`);
+    if (!process.stdin.isTTY)
+        return null;
+    const readline = await import("node:readline/promises");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const choice = (await rl.question(`  ${CY}Selection: ${R}`)).trim();
+        if (!choice)
+            return null;
+        if (/^\d+$/.test(choice)) {
+            const idx = Number(choice) - 1;
+            if (idx >= 0 && idx < found.length)
+                return found[idx];
+        }
+        if (fs.existsSync(choice))
+            return path.resolve(choice);
+        console.log(`  ${RD}[-] Invalid selection.${R}`);
+        return null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        rl.close();
+    }
+}
+function collectGguf(dir, acc, depth) {
+    if (depth > 6)
+        return;
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        const full = path.join(dir, e.name);
+        if (e.isDirectory())
+            collectGguf(full, acc, depth + 1);
+        else if (e.name.toLowerCase().endsWith(".gguf"))
+            acc.push(full);
+    }
+}
+/* ── Main ─────────────────────────────────────────────────────────────────── */
+export async function main(argv = process.argv.slice(2)) {
+    const args = parseArgs(argv);
+    const pos = args.positional;
+    if (args.version) {
+        console.log(`axoniz-zero ${VERSION}`);
+        return;
+    }
+    if (args.help) {
+        console.log(HELP);
+        return;
+    }
+    const runner = new Runner();
+    const cfg = runner.cfg;
+    const ov = overridesFromArgs(args);
+    const logger = getLogger();
+    logger.info(`CLI started | version=${VERSION} | args=${JSON.stringify(args)}`);
+    logger.logEvent("cli_start", { version: VERSION, args });
+    // ── Sovereign model selection ──
+    const provider = String(ov.provider ?? activeProvider(cfg));
+    const isLocalGguf = provider === "llamacpp" || provider === "gguf";
+    const cfgAny = cfg;
+    if ((args.lc || args.goal || args.cli) &&
+        isLocalGguf &&
+        !ov.model_path &&
+        !cfgAny.model_path) {
+        const selected = await interactiveModelSelect();
+        if (selected) {
+            ov.model_path = selected;
+            logger.info(`User selected model: ${selected}`);
+            console.log(`  ${GB}[+] ${DG}Using model: ${path.basename(selected)}${R}\n`);
+        }
+        else if (!args.pipe) {
+            logger.error("No model selected for local GGUF backend");
+            console.log(`  ${RD}[-] Model required for ${provider}.${R}\n`);
+            process.exit(1);
+        }
+    }
+    // ── Subcommands ──
+    if (pos.length > 0) {
+        const cmd = pos[0].toLowerCase();
+        if (cmd === "model" || cmd === "models") {
+            const { showTable, get: getModel } = await import("./models.js");
+            const action = pos[1]?.toLowerCase() ?? "list";
+            const name = pos[2];
+            if (["list", "ls", "all"].includes(action)) {
+                await showTable();
+            }
+            else if (action === "download" && name) {
+                const filename = pos[3];
+                const { downloadModel } = await import("./downloader.js");
+                await downloadModel(name, filename);
+            }
+            else if (action === "use" && name) {
+                const m = getModel(name);
+                if (m) {
+                    cfgAny.model_name = m.name;
+                    cfgAny.temperature = m.temperature;
+                    cfgAny.max_tokens = m.max_tokens;
+                    saveConfig(cfgAny);
+                    logger.info(`Model switched to ${m.name}`);
+                    console.log(`  ${GB}[+] Switched to ${m.name}${R}`);
+                }
+                else {
+                    cfgAny.model_name = name;
+                    saveConfig(cfgAny);
+                    logger.info(`Model set to ${name}`);
+                    console.log(`  ${GB}[+] Model set to '${name}'${R}`);
+                }
+            }
+            return;
+        }
+        if (cmd === "config") {
+            const action = pos[1]?.toLowerCase() ?? "show";
+            if (action === "show") {
+                showConfig();
+            }
+            else if (action === "set" && pos.length > 2) {
+                for (const pair of pos.slice(2)) {
+                    if (!pair.includes("="))
+                        continue;
+                    const idx = pair.indexOf("=");
+                    const k = pair.slice(0, idx).trim();
+                    const rawV = pair.slice(idx + 1);
+                    let v = rawV;
+                    if (/^-?\d+$/.test(rawV))
+                        v = parseInt(rawV, 10);
+                    else if (/^-?\d*\.\d+$/.test(rawV))
+                        v = parseFloat(rawV);
+                    const old = cfgAny[k];
+                    cfgAny[k] = v;
+                    saveConfig(cfgAny);
+                    logger.logConfigChange(k, old, v);
+                    console.log(`  ${GB}[+] ${DG}${k} = ${String(v)}${R}`);
+                }
+            }
+            else if (action === "reset") {
+                resetConfig();
+                logger.info("Config reset to defaults");
+            }
+            return;
+        }
+        if (cmd === "memory" || cmd === "mem" || cmd === "palace") {
+            // Handled below, once an agent exists.
+        }
+        else if (cmd === "setup") {
+            // first_run is an optional convenience module. The dynamic specifier is
+            // built at runtime so TypeScript does not require the file to exist.
+            const setupPath = "./first_run.js";
+            try {
+                const m = (await import(setupPath));
+                await m.runSetup();
+            }
+            catch (e) {
+                logError(`setup unavailable (module not ported): ${errMsg(e)}`);
+                console.log(`  ${YL}setup is not available in this build.${R}`);
+            }
+            return;
+        }
+    }
+    // ── No args -> help ──
+    if (pos.length === 0 &&
+        !args.lc &&
+        !args.cli &&
+        !args.web &&
+        !args.goal &&
+        !args.pipe) {
+        console.log(HELP);
+        return;
+    }
+    // ── Build agent ──
+    const model = String(ov.model_name ?? cfgAny.model_name ?? "");
+    const workspace = String(ov.workspace ?? cfgAny.workspace ?? ".");
+    console.log(`\n  ${PURPLE}${B}FRAZIYM AI${R}  ${DG}v${VERSION}${R}`);
+    const provStr = String(ov.provider ?? cfg.llm?.active_provider ?? cfgAny.backend ?? "llamacpp");
+    console.log(`  ${DG}backend${R}      ${GR}${provStr}${R}`);
+    console.log(`  ${DG}eye${R}          ${GR}axodex graph active${R}`);
+    console.log(`  ${DG}swarm${R}        ${GR}swarm engine ready${R}`);
+    console.log(`  ${DG}workspace${R}    ${GR}${path.resolve(workspace)}${R}\n`);
+    logger.info(`Building agent | provider=${provStr} | workspace=${workspace}`);
+    // ── Memory / palace subcommands need an agent ──
+    if (pos.length > 0) {
+        const cmd = pos[0].toLowerCase();
+        if (cmd === "memory" || cmd === "mem") {
+            const agent = await runner.buildAgent(ov);
+            const mem = agent.memory.all();
+            const keys = Object.keys(mem);
+            if (keys.length > 0) {
+                section("semantic memory");
+                for (const k of keys.slice(0, 20))
+                    kv(k, String(mem[k]).slice(0, 72));
+            }
+            else {
+                console.log(`  ${DG}(empty)${R}`);
+            }
+            return;
+        }
+        if (cmd === "palace") {
+            const agent = await runner.buildAgent(ov);
+            const st = agent.memory.palace.status();
+            console.log(`\n  ${DG}palace: ${st.total_drawers ?? 0} drawers${R}`);
+            for (const [w, count] of Object.entries(st.wings ?? {}).slice(0, 10)) {
+                console.log(`    ${DG}${w.padEnd(30)}${R}${GR}${count} drawers${R}`);
+            }
+            return;
+        }
+    }
+    let agent;
+    try {
+        agent = await runner.buildAgent(ov);
+        logger.logAgentInit({ provider: provStr, workspace, model });
+    }
+    catch (e) {
+        logger.logAgentError(e, "build_agent");
+        console.log(`\n  ${RD}\u2717 Failed to start: ${errMsg(e)}${R}\n`);
+        if (e instanceof Error)
+            console.error(e.stack);
+        process.exit(1);
+    }
+    if (!(await runner.checkBackend(agent))) {
+        logger.error("Backend health check failed");
+        process.exit(1);
+    }
+    const h = await agent.health();
+    const provStr2 = String(agent.config.provider ??
+        agent.config.backend ??
+        "llamacpp");
+    const mdlStr = String(h.model ?? agent.config.model_name ?? "auto");
+    const dot = h.status === "ok" ? `${GB}[*]${R}` : `${YL}[!]${R}`;
+    console.log(`  ${dot}  ${DG}${provStr2}${R}  ${DG}/${R}  ${GR}${mdlStr}${R}\n`);
+    logger.logBackendHealth(provStr2, h);
+    // ── Web-only mode ──
+    if (args.web && !args.lc && !args.cli && !args.goal) {
+        try {
+            const { fullBoot } = (await import("../startup.js"));
+            await fullBoot({
+                cfg: null,
+                overrides: Object.keys(ov).length > 0 ? ov : null,
+                port: args.port,
+                openBrowser: true,
+                web: true,
+            });
+        }
+        catch (e) {
+            if (e instanceof Error && e.name === "AbortError") {
+                logger.info("Web server stopped by user");
+                console.log(`\n  ${DG}stopped.${R}`);
+            }
+            else {
+                throw e;
+            }
+        }
+        finally {
+            logger.logSessionEnd("web_stop");
+        }
+        return;
+    }
+    // ── Build the CLI ──
+    const { CLI } = await import("./cli.js");
+    let webUrl = null;
+    if (args.web) {
+        const { WebServer } = await import("../web/server.js");
+        const ws = new WebServer({ agent, port: args.port });
+        // Start in the background; the CLI keeps the foreground.
+        void ws.listen().then((url) => {
+            console.log(`  ${CY}web \u2192${R} ${BL}${url}${R}`);
+        });
+        webUrl = `http://localhost:${args.port}`;
+        await sleep(800);
+    }
+    const cli = new CLI(agent, webUrl);
+    // ── Pipe ──
+    if (args.pipe || (!process.stdin.isTTY && !args.lc)) {
+        const task = (await readStdin()).trim();
+        if (task) {
+            logger.logAgentRun(task, "pipe");
+            await cli.runAgent(task);
+        }
+        logger.logSessionEnd("pipe_done");
+        return;
+    }
+    // ── Positional inline task ──
+    let task = null;
+    if (pos.length > 0) {
+        const skip = new Set([
+            "run",
+            "web",
+            "config",
+            "memory",
+            "mem",
+            "setup",
+            "model",
+            "models",
+            "backends",
+            "palace",
+        ]);
+        if (!skip.has(pos[0].toLowerCase())) {
+            task = pos.join(" ").trim();
+        }
+        else if (pos[0].toLowerCase() === "run" && pos.length > 1) {
+            task = pos.slice(1).join(" ").trim();
+        }
+    }
+    if (task) {
+        logger.logAgentRun(task, "inline");
+        await cli.runAgent(task);
+        logger.logSessionEnd("inline_done");
+        return;
+    }
+    if (args.goal) {
+        logger.logAgentRun(args.goal, "goal");
+        await cli.runGoal(args.goal);
+        logger.logSessionEnd("goal_done");
+        return;
+    }
+    if (args.cli) {
+        let oneShot;
+        if (process.stdin.isTTY) {
+            const readline = await import("node:readline/promises");
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            try {
+                oneShot = (await rl.question(`  ${DG}Task: ${R}`)).trim();
+            }
+            catch {
+                rl.close();
+                return;
+            }
+            rl.close();
+        }
+        else {
+            oneShot = (await readStdin()).trim();
+        }
+        if (oneShot) {
+            logger.logAgentRun(oneShot, "cli");
+            await cli.runAgent(oneShot);
+        }
+        logger.logSessionEnd("cli_done");
+        return;
+    }
+    // ── Interactive REPL ──
+    logger.logAgentRun("", "repl");
+    try {
+        await cli.run();
+    }
+    catch (e) {
+        if (!(e instanceof Error && e.name === "AbortError"))
+            throw e;
+    }
+    finally {
+        logger.logSessionEnd("repl_stop");
+    }
+}
+/* ── Helpers ──────────────────────────────────────────────────────────────── */
+function errMsg(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString("utf-8");
+}
+export { os, AXONIZ_HOME, debug };
+//# sourceMappingURL=runner.js.map