@offerpilot/axiomruntime 0.0.1

package/dist/cli/commands/use.js

@@ -0,0 +1,108 @@
+import { readCache, recordProviderRuntimeFailure, recordProviderRuntimeSuccess } from "../../core/config/cache-store.js";
+import { writeLog } from "../../core/logs/log-service.js";
+import { refreshAllProviders } from "../../core/providers/provider-service.js";
+import { resolveProviderCandidatesForTool } from "../../core/runner/fallback.js";
+import { runTool } from "../../core/runner/tool-runner.js";
+import { promptConfirm, promptSelect } from "../prompts/prompt.js";
+export async function runUseCommand(args) {
+    const tool = await getTool(args[0]);
+    const providerName = args[1];
+    const modelName = args[2];
+    await refreshAllProviders();
+    const candidates = await resolveProviderCandidatesForTool(tool, providerName, modelName);
+    if (!candidates.length) {
+        throw new Error("No usable provider/model found. Run `ai status` or `ai doctor`.");
+    }
+    const code = await runResolvedProviderCandidates(tool, candidates, {
+        confirm: promptConfirm,
+        runner: (candidate, fallbackFrom) => runTool(tool, candidate.provider, candidate.model, { fallbackFrom })
+    });
+    process.exitCode = code;
+}
+export async function runLastCommand() {
+    const cache = await readCache();
+    if (!cache.lastSelection) {
+        console.log("No last selection found.");
+        return;
+    }
+    await runUseCommand([cache.lastSelection.tool, cache.lastSelection.provider, cache.lastSelection.model]);
+}
+async function getTool(value) {
+    if (value === "claude" || value === "codex") {
+        return value;
+    }
+    return promptSelect("Select tool", [
+        { label: "claude", value: "claude" },
+        { label: "codex", value: "codex" }
+    ]);
+}
+export async function runResolvedProviderCandidates(tool, candidates, options = {}) {
+    const confirm = options.confirm ?? promptConfirm;
+    const runner = options.runner ?? ((candidate, fallbackFrom) => runTool(tool, candidate.provider, candidate.model, { fallbackFrom }));
+    let lastExitCode = 1;
+    let runtimeFallbackFrom = null;
+    for (const [index, candidate] of candidates.entries()) {
+        const fallbackFrom = runtimeFallbackFrom ?? candidate.fallbackFrom ?? null;
+        if (fallbackFrom) {
+            console.log(`Provider ${fallbackFrom} unavailable, fallback to ${candidate.provider.name}.`);
+            await writeProviderFallbackLog({
+                action: "fallback_applied",
+                from: fallbackFrom,
+                to: candidate.provider.name,
+                tool,
+                model: candidate.model
+            });
+        }
+        console.log(`Using ${tool}: ${candidate.provider.name} / ${candidate.model}`);
+        await writeLog({
+            category: "usage",
+            action: "tool_start",
+            message: `Starting ${tool}: ${candidate.provider.name} / ${candidate.model}`,
+            metadata: { tool, provider: candidate.provider.name, model: candidate.model, mode: candidate.provider.mode }
+        });
+        if (candidate.provider.mode === "ask") {
+            const confirmed = await confirm("Start CLI?");
+            if (!confirmed)
+                return 0;
+        }
+        const code = await runner(candidate, fallbackFrom);
+        if (code === 0) {
+            await recordProviderRuntimeSuccess(candidate.provider.name);
+            return 0;
+        }
+        lastExitCode = code;
+        await recordProviderRuntimeFailure(candidate.provider.name, `exit_code_${code}`);
+        const next = candidates[index + 1];
+        if (next) {
+            runtimeFallbackFrom = candidate.provider.name;
+            await writeProviderFallbackLog({
+                level: "warn",
+                action: "runtime_fallback_retry",
+                from: candidate.provider.name,
+                to: next.provider.name,
+                tool,
+                model: candidate.model,
+                nextModel: next.model,
+                error: `exit_code_${code}`
+            });
+            console.log(`Provider ${candidate.provider.name} failed with exit code ${code}, trying ${next.provider.name}.`);
+        }
+    }
+    return lastExitCode;
+}
+async function writeProviderFallbackLog(input) {
+    await writeLog({
+        level: input.level,
+        category: "strategy",
+        action: input.action,
+        message: `Provider fallback ${input.from} -> ${input.to} for ${input.tool}.`,
+        metadata: {
+            from: input.from,
+            to: input.to,
+            engine: input.tool,
+            model: input.model,
+            nextModel: input.nextModel ?? null,
+            error: input.error ?? null
+        }
+    });
+}

package/dist/cli/commands/version.js

@@ -0,0 +1,12 @@
+import { createRequire } from "node:module";
+export function getRuntimeVersion() {
+    const require = createRequire(import.meta.url);
+    const metadata = require("../../../package.json");
+    if (typeof metadata.version !== "string" || !metadata.version.trim()) {
+        throw new Error("Runtime package version is unavailable.");
+    }
+    return metadata.version;
+}
+export async function runVersionCommand() {
+    console.log(getRuntimeVersion());
+}

package/dist/cli/index.js

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+import { runAddCommand } from "./commands/add.js";
+import { runContextCommand } from "./commands/context.js";
+import { runDoctorCommand } from "./commands/doctor.js";
+import { runProviderDeleteCommand, runProviderEditCommand } from "./commands/edit.js";
+import { runHelpCommand } from "./commands/help.js";
+import { runListCommand } from "./commands/list.js";
+import { runLogCommand } from "./commands/log.js";
+import { runMemoryCommand } from "./commands/memory.js";
+import { runReportCommand } from "./commands/report.js";
+import { runLastCommand, runUseCommand } from "./commands/use.js";
+import { runSessionCommand } from "./commands/session.js";
+import { runSetupCommand } from "./commands/setup.js";
+import { runStatusCommand } from "./commands/status.js";
+import { runTelegramCommand } from "./commands/telegram.js";
+import { runVersionCommand } from "./commands/version.js";
+import { writeLog } from "../core/logs/log-service.js";
+import { promptSelect } from "./prompts/prompt.js";
+import { getCliCommand, registerCliCommand } from "./registry.js";
+registerBuiltInCommands();
+async function main() {
+    const [, , command, ...args] = process.argv;
+    const registered = command === undefined ? undefined : getCliCommand(command);
+    if (registered?.logUsage === false) {
+        await registered.run(args);
+        return;
+    }
+    const safeArgs = sanitizeArgs(command, args);
+    await writeLog({
+        category: "usage",
+        action: "command_start",
+        message: `Command started: ${command ?? "interactive"}`,
+        metadata: { command: command ?? "interactive", args: safeArgs }
+    });
+    if (command === undefined) {
+        await runInteractive();
+        return;
+    }
+    if (registered) {
+        await registered.run(args);
+        return;
+    }
+    await writeLog({
+        level: "warn",
+        category: "usage",
+        action: "unknown_command",
+        message: `Unknown command: ${command}`,
+        metadata: { command, args: safeArgs }
+    });
+    console.error(`Unknown command: ${command}`);
+    console.error("Run `ai help` for usage.");
+    process.exitCode = 1;
+}
+function sanitizeArgs(command, args) {
+    if (command === "add" && args.length >= 3) {
+        return [args[0], args[1], maskSecretArg(args[2])];
+    }
+    if (command === "provider" && args[0] === "add" && args.length >= 4) {
+        return [args[0], args[1], args[2], maskSecretArg(args[3])];
+    }
+    if (command === "memory" && (args[0] === "embedding" || args[0] === "vector") && (args[1] === "set" || args[1] === "edit")) {
+        return maskMemoryEmbeddingSetArgs(args);
+    }
+    if (command === "telegram") {
+        return maskTelegramConfigSecretArgs(args);
+    }
+    return args.map((arg, index) => {
+        const previous = args[index - 1]?.toLowerCase();
+        if (previous === "--api-key" || previous === "--apikey" || previous === "--key") {
+            return maskSecretArg(arg);
+        }
+        return arg;
+    });
+}
+function maskTelegramConfigSecretArgs(args) {
+    const masked = [...args];
+    let state = "config";
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--bot") {
+            index += 1;
+            continue;
+        }
+        if (arg === "--all" || arg.startsWith("--bot="))
+            continue;
+        if (state === "config" && arg === "config") {
+            state = "set";
+            continue;
+        }
+        if (state === "set" && arg === "set") {
+            state = "token";
+            continue;
+        }
+        if (state === "token" && arg === "token") {
+            state = "done";
+            continue;
+        }
+        if (state === "done") {
+            masked[index] = maskSecretArg(arg);
+            break;
+        }
+    }
+    return masked;
+}
+function maskMemoryEmbeddingSetArgs(args) {
+    const valueOptions = new Set(["--type", "--provider-type", "--query-task", "--passage-task", "--dimensions", "--api-key", "--apikey", "--key"]);
+    const masked = [...args];
+    let positional = 0;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg.startsWith("--"))
+            continue;
+        const previous = args[index - 1]?.toLowerCase();
+        if (previous === "--api-key" || previous === "--apikey" || previous === "--key") {
+            masked[index] = maskSecretArg(arg);
+            continue;
+        }
+        if (previous && valueOptions.has(previous))
+            continue;
+        if (index >= 2) {
+            positional += 1;
+            if (positional === 3)
+                masked[index] = maskSecretArg(arg);
+        }
+    }
+    return masked;
+}
+function maskSecretArg(value) {
+    if (value.length <= 8)
+        return "****";
+    return `${value.slice(0, 4)}****${value.slice(-4)}`;
+}
+async function runInteractive() {
+    const interactiveCommandNames = ["setup", "use", "add", "memory", "telegram", "status", "session", "report", "doctor", "log", "context", "help", "last"];
+    const command = await promptSelect("AI Gateway", [
+        ...interactiveCommandNames
+            .flatMap((name) => {
+            const item = getCliCommand(name);
+            return item ? [{ label: item.description, value: item.name }] : [];
+        }),
+        { label: "provider list", value: "provider:list" },
+        { label: "provider edit", value: "provider:edit" },
+        { label: "provider delete", value: "provider:delete" },
+        { label: "exit", value: "exit" }
+    ]);
+    if (command === "exit")
+        return;
+    if (command === "provider:list")
+        await runListCommand();
+    if (command === "provider:edit")
+        await runProviderEditCommand();
+    if (command === "provider:delete")
+        await runProviderDeleteCommand();
+    const registered = getCliCommand(command);
+    if (registered)
+        await registered.run([]);
+}
+async function runProviderCommand(args) {
+    const [subcommand, name] = args;
+    if (subcommand === "add") {
+        await runAddCommand(args.slice(1));
+        return;
+    }
+    if (subcommand === "list") {
+        await runListCommand();
+        return;
+    }
+    if (subcommand === "edit") {
+        await runProviderEditCommand(name);
+        return;
+    }
+    if (subcommand === "delete" || subcommand === "remove") {
+        await runProviderDeleteCommand(name);
+        return;
+    }
+    throw new Error(`Unknown provider command: ${subcommand ?? "(missing)"}`);
+}
+function registerBuiltInCommands() {
+    registerCliCommand({
+        name: "version",
+        aliases: ["--version", "-v", "-V"],
+        description: "version",
+        interactive: false,
+        logUsage: false,
+        run: () => runVersionCommand()
+    });
+    registerCliCommand({
+        name: "setup",
+        description: "setup",
+        run: (args) => runSetupCommand(args)
+    });
+    registerCliCommand({
+        name: "help",
+        description: "help",
+        run: () => runHelpCommand()
+    });
+    registerCliCommand({
+        name: "add",
+        description: "provider add",
+        run: (args) => runAddCommand(args)
+    });
+    registerCliCommand({
+        name: "status",
+        description: "status",
+        run: () => runStatusCommand()
+    });
+    registerCliCommand({
+        name: "provider",
+        description: "provider add",
+        interactive: false,
+        run: (args) => runProviderCommand(args)
+    });
+    registerCliCommand({
+        name: "session",
+        description: "session",
+        run: (args) => runSessionCommand(args)
+    });
+    registerCliCommand({
+        name: "report",
+        description: "report",
+        run: (args) => runReportCommand(args)
+    });
+    registerCliCommand({
+        name: "log",
+        description: "log",
+        run: (args) => runLogCommand(args)
+    });
+    registerCliCommand({
+        name: "context",
+        description: "context",
+        run: (args) => runContextCommand(args)
+    });
+    registerCliCommand({
+        name: "telegram",
+        description: "telegram",
+        run: (args) => runTelegramCommand(args)
+    });
+    registerCliCommand({
+        name: "memory",
+        description: "memory",
+        run: (args) => runMemoryCommand(args)
+    });
+    registerCliCommand({
+        name: "doctor",
+        description: "doctor",
+        run: (args) => runDoctorCommand(args)
+    });
+    registerCliCommand({
+        name: "use",
+        description: "use",
+        run: (args) => runUseCommand(args)
+    });
+    registerCliCommand({
+        name: "last",
+        description: "last",
+        run: () => runLastCommand()
+    });
+    registerCliCommand({
+        name: "web",
+        description: "web",
+        interactive: false,
+        run: async () => {
+            console.log("`ai web` is planned but not implemented in this foundation build.");
+        }
+    });
+}
+main().catch(async (error) => {
+    await writeLog({
+        level: "error",
+        category: "error",
+        action: "command_error",
+        message: error instanceof Error ? error.message : String(error)
+    });
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/cli/output/table.js

@@ -0,0 +1,22 @@
+export function printTable(rows) {
+    if (!rows.length) {
+        console.log("No data.");
+        return;
+    }
+    const headers = Object.keys(rows[0]);
+    const widths = headers.map((header) => Math.max(header.length, ...rows.map((row) => String(row[header] ?? "").length)));
+    const line = headers.map((header, index) => header.padEnd(widths[index])).join("  ");
+    const separator = widths.map((width) => "-".repeat(width)).join("  ");
+    console.log(line);
+    console.log(separator);
+    for (const row of rows) {
+        console.log(headers.map((header, index) => String(row[header] ?? "").padEnd(widths[index])).join("  "));
+    }
+}
+export function maskSecret(value) {
+    if (!value)
+        return "";
+    if (value.length <= 8)
+        return "****";
+    return `${value.slice(0, 4)}****${value.slice(-4)}`;
+}

package/dist/cli/prompts/prompt.js

@@ -0,0 +1,37 @@
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+export async function promptText(message, options = {}) {
+    const rl = readline.createInterface({ input, output });
+    try {
+        const suffix = options.defaultValue ? ` (${options.defaultValue})` : "";
+        const answer = await rl.question(`${message}${suffix}: `);
+        return answer.trim() || options.defaultValue || "";
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function promptConfirm(message, defaultValue = false) {
+    const fallback = defaultValue ? "Y/n" : "y/N";
+    const answer = (await promptText(`${message} [${fallback}]`)).toLowerCase();
+    if (!answer)
+        return defaultValue;
+    return answer === "y" || answer === "yes";
+}
+export async function promptSelect(message, choices) {
+    if (!choices.length) {
+        throw new Error(`No choices available for: ${message}`);
+    }
+    console.log(`\n${message}`);
+    choices.forEach((choice, index) => {
+        console.log(`  ${index + 1}. ${choice.label}`);
+    });
+    while (true) {
+        const raw = await promptText("Select");
+        const index = Number(raw);
+        if (Number.isInteger(index) && index >= 1 && index <= choices.length) {
+            return choices[index - 1].value;
+        }
+        console.log(`Please enter a number between 1 and ${choices.length}.`);
+    }
+}

package/dist/cli/registry.js

@@ -0,0 +1,16 @@
+const commands = new Map();
+export function registerCliCommand(command) {
+    commands.set(command.name, command);
+    for (const alias of command.aliases ?? []) {
+        commands.set(alias, command);
+    }
+}
+export function getCliCommand(name) {
+    return commands.get(name);
+}
+export function listCliCommands() {
+    return [...new Set(commands.values())];
+}
+export function listInteractiveCliCommands() {
+    return listCliCommands().filter((command) => command.interactive !== false);
+}

package/dist/core/config/cache-store.js

@@ -0,0 +1,193 @@
+import { getCachePath } from "./paths.js";
+import { readJsonFile, updateJsonFile, writeJsonFile } from "./json-store.js";
+const EMPTY_CACHE = { providers: {} };
+const PROVIDER_CIRCUIT_FAILURE_THRESHOLD = 3;
+const PROVIDER_CIRCUIT_OPEN_MS = 10 * 60 * 1000;
+const DEFAULT_HEALTH_SCORE = 50;
+const HEALTH_SCORE_SUCCESS_STEP = 25;
+const HEALTH_SCORE_FAILURE_STEP = 35;
+export async function readCache() {
+    const cache = await readJsonFile(getCachePath(), EMPTY_CACHE);
+    return normalizeCache(cache);
+}
+export async function writeCache(cache) {
+    await writeJsonFile(getCachePath(), normalizeCache(cache));
+}
+export async function upsertProviderCache(providerName, providerCache) {
+    await updateJsonFile(getCachePath(), EMPTY_CACHE, (cache) => {
+        const next = normalizeCache(cache);
+        next.providers[providerName] = normalizeProviderCache(providerCache);
+        return next;
+    });
+}
+export async function recordProviderRuntimeSuccess(providerName) {
+    const checkedAt = new Date().toISOString();
+    let updated = null;
+    await updateJsonFile(getCachePath(), EMPTY_CACHE, (cache) => {
+        const next = normalizeCache(cache);
+        updated = applyProviderHealth(next.providers[providerName], {
+            status: "ok",
+            models: next.providers[providerName]?.models ?? [],
+            lastCheckedAt: checkedAt,
+            lastError: null
+        });
+        next.providers[providerName] = updated;
+        return next;
+    });
+    return updated;
+}
+export async function recordProviderRuntimeFailure(providerName, error) {
+    const checkedAt = new Date().toISOString();
+    const lastError = summarizeHealthError(error);
+    let updated = null;
+    await updateJsonFile(getCachePath(), EMPTY_CACHE, (cache) => {
+        const next = normalizeCache(cache);
+        const previous = next.providers[providerName] ? normalizeProviderCache(next.providers[providerName]) : undefined;
+        const consecutiveFailures = (previous?.consecutiveFailures ?? 0) + 1;
+        const circuitOpenUntil = consecutiveFailures >= PROVIDER_CIRCUIT_FAILURE_THRESHOLD
+            ? new Date(Date.now() + PROVIDER_CIRCUIT_OPEN_MS).toISOString()
+            : null;
+        updated = {
+            status: circuitOpenUntil ? "error" : previous?.status ?? "unknown",
+            models: previous?.models ?? [],
+            lastCheckedAt: checkedAt,
+            lastError,
+            consecutiveFailures,
+            lastFailureAt: checkedAt,
+            circuitOpenUntil,
+            healthScore: clampHealthScore((previous?.healthScore ?? DEFAULT_HEALTH_SCORE) - HEALTH_SCORE_FAILURE_STEP)
+        };
+        next.providers[providerName] = updated;
+        return next;
+    });
+    return updated;
+}
+export function buildProviderHealthCache(previous, next) {
+    return applyProviderHealth(previous, normalizeProviderCache(next));
+}
+export function isProviderCircuitOpen(providerCache, now = Date.now()) {
+    if (!providerCache?.circuitOpenUntil)
+        return false;
+    const openUntil = Date.parse(providerCache.circuitOpenUntil);
+    return Number.isFinite(openUntil) && openUntil > now;
+}
+export async function renameProviderCache(from, to) {
+    if (from === to)
+        return;
+    await updateJsonFile(getCachePath(), EMPTY_CACHE, (cache) => {
+        const next = normalizeCache(cache);
+        if (next.providers[from]) {
+            next.providers[to] = next.providers[from];
+            delete next.providers[from];
+        }
+        if (next.lastSelection?.provider === from) {
+            next.lastSelection.provider = to;
+        }
+        return next;
+    });
+}
+export async function deleteProviderCache(providerName) {
+    await updateJsonFile(getCachePath(), EMPTY_CACHE, (cache) => {
+        const next = normalizeCache(cache);
+        delete next.providers[providerName];
+        if (next.lastSelection?.provider === providerName) {
+            delete next.lastSelection;
+        }
+        return next;
+    });
+}
+export async function saveLastSelection(tool, provider, model) {
+    await updateJsonFile(getCachePath(), EMPTY_CACHE, (cache) => ({
+        ...normalizeCache(cache),
+        lastSelection: {
+            tool,
+            provider,
+            model,
+            usedAt: new Date().toISOString()
+        }
+    }));
+}
+function normalizeCache(cache) {
+    const providers = {};
+    for (const [name, value] of Object.entries(cache.providers ?? {})) {
+        providers[name] = normalizeProviderCache(value);
+    }
+    return {
+        providers,
+        lastSelection: cache.lastSelection
+    };
+}
+function applyProviderHealth(previous, next) {
+    const normalizedPrevious = previous ? normalizeProviderCache(previous) : undefined;
+    const normalizedNext = normalizeProviderCache(next);
+    const previousScore = normalizedPrevious?.healthScore ?? DEFAULT_HEALTH_SCORE;
+    if (normalizedNext.status === "ok") {
+        return {
+            ...normalizedNext,
+            consecutiveFailures: 0,
+            lastFailureAt: null,
+            circuitOpenUntil: null,
+            healthScore: clampHealthScore(previousScore + HEALTH_SCORE_SUCCESS_STEP)
+        };
+    }
+    if (normalizedNext.status === "error") {
+        const consecutiveFailures = (normalizedPrevious?.consecutiveFailures ?? 0) + 1;
+        return {
+            ...normalizedNext,
+            consecutiveFailures,
+            lastFailureAt: normalizedNext.lastCheckedAt,
+            circuitOpenUntil: consecutiveFailures >= PROVIDER_CIRCUIT_FAILURE_THRESHOLD
+                ? new Date(Date.now() + PROVIDER_CIRCUIT_OPEN_MS).toISOString()
+                : null,
+            healthScore: clampHealthScore(previousScore - HEALTH_SCORE_FAILURE_STEP)
+        };
+    }
+    return {
+        ...normalizedNext,
+        consecutiveFailures: normalizedPrevious?.consecutiveFailures ?? 0,
+        lastFailureAt: normalizedPrevious?.lastFailureAt ?? null,
+        circuitOpenUntil: normalizedPrevious?.circuitOpenUntil ?? null,
+        healthScore: clampHealthScore(previousScore)
+    };
+}
+function normalizeProviderCache(value) {
+    const status = normalizeHealthStatus(value.status);
+    return {
+        status,
+        models: Array.isArray(value.models) ? value.models.map(String).filter(Boolean) : [],
+        lastCheckedAt: normalizeNullableString(value.lastCheckedAt),
+        lastError: normalizeNullableString(value.lastError),
+        consecutiveFailures: normalizeNonNegativeInteger(value.consecutiveFailures),
+        lastFailureAt: normalizeNullableString(value.lastFailureAt),
+        circuitOpenUntil: normalizeNullableString(value.circuitOpenUntil),
+        healthScore: clampHealthScore(typeof value.healthScore === "number" && Number.isFinite(value.healthScore)
+            ? value.healthScore
+            : status === "ok"
+                ? 100
+                : status === "error"
+                    ? 0
+                    : DEFAULT_HEALTH_SCORE)
+    };
+}
+function normalizeHealthStatus(value) {
+    return value === "ok" || value === "error" || value === "unknown" ? value : "unknown";
+}
+function normalizeNullableString(value) {
+    if (value === null || value === undefined)
+        return null;
+    const text = String(value).trim();
+    return text || null;
+}
+function normalizeNonNegativeInteger(value) {
+    const numberValue = Number(value ?? 0);
+    return Number.isInteger(numberValue) && numberValue > 0 ? numberValue : 0;
+}
+function clampHealthScore(value) {
+    if (!Number.isFinite(value))
+        return DEFAULT_HEALTH_SCORE;
+    return Math.max(0, Math.min(100, Math.round(value)));
+}
+function summarizeHealthError(error) {
+    const message = error instanceof Error ? error.message : String(error ?? "Provider failed.");
+    return message.replace(/\s+/g, " ").trim().slice(0, 240) || "Provider failed.";
+}