@offerpilot/axiomruntime 0.0.1

package/dist/cli/commands/memory.js

@@ -0,0 +1,241 @@
+import { checkAndRecordMemoryEmbeddingConfig } from "../../core/memory/embedding-check.js";
+import { clearMemoryEmbeddingConfig, getMemoryEmbeddingConfig, setMemoryEmbeddingConfig } from "../../core/memory/memory-config.js";
+import { writeLog } from "../../core/logs/log-service.js";
+import { maskSecret } from "../output/table.js";
+import { promptConfirm, promptSelect, promptText } from "../prompts/prompt.js";
+export async function runMemoryCommand(args) {
+    const [area, action, ...rest] = args;
+    if (area === undefined || area === "embedding" || area === "vector") {
+        await runMemoryEmbeddingCommand(area === undefined ? args : [action, ...rest].filter((item) => Boolean(item)));
+        return;
+    }
+    throw new Error(`Unknown memory command: ${area}`);
+}
+async function runMemoryEmbeddingCommand(args) {
+    if (!args.length) {
+        await runMemoryEmbeddingInteractive();
+        return;
+    }
+    const [action = "show", ...rest] = args;
+    if (action === "show" || action === "status") {
+        await showMemoryEmbeddingConfig();
+        return;
+    }
+    if (action === "set" || action === "edit") {
+        await setEmbeddingConfig(rest);
+        return;
+    }
+    if (action === "test" || action === "check") {
+        await testEmbeddingConfig(rest.join(" ").trim() || undefined);
+        return;
+    }
+    if (action === "clear" || action === "delete" || action === "remove") {
+        await clearEmbeddingConfig();
+        return;
+    }
+    throw new Error(`Unknown memory embedding command: ${action}`);
+}
+async function runMemoryEmbeddingInteractive() {
+    const config = await getMemoryEmbeddingConfig();
+    const action = await promptSelect("Memory embedding", [
+        { label: config ? `show current config (${config.name} / ${config.model})` : "show current config", value: "show" },
+        { label: config ? "edit embedding model" : "set embedding model", value: "set" },
+        ...(config ? [
+            { label: "test embedding model", value: "test" },
+            { label: "clear embedding model", value: "clear" }
+        ] : []),
+        { label: "exit", value: "exit" }
+    ]);
+    if (action === "exit")
+        return;
+    if (action === "show") {
+        await showMemoryEmbeddingConfig();
+        return;
+    }
+    if (action === "set") {
+        await setEmbeddingConfig([]);
+        return;
+    }
+    if (action === "test") {
+        await testEmbeddingConfig();
+        return;
+    }
+    if (action === "clear") {
+        await clearEmbeddingConfig();
+    }
+}
+async function showMemoryEmbeddingConfig() {
+    const config = await getMemoryEmbeddingConfig();
+    if (!config) {
+        console.log("No memory embedding model configured.");
+        console.log("Run `ai memory embedding set` to configure one.");
+        return;
+    }
+    printEmbeddingConfig(config);
+}
+async function setEmbeddingConfig(args) {
+    const options = parseSetOptions(args);
+    const positional = parseSetPositionals(args);
+    const existing = await getMemoryEmbeddingConfig();
+    const interactive = positional.length < 4;
+    const name = positional[0] ?? await promptText("Embedding provider name", { defaultValue: existing?.name ?? "jina" });
+    const baseUrl = positional[1] ?? await promptText("Embedding base URL", { defaultValue: existing?.baseUrl ?? "https://api.jina.ai/v1" });
+    const apiKey = positional[2] ?? await promptApiKey(existing?.apiKey);
+    const model = positional[3] ?? await promptText("Embedding model", { defaultValue: existing?.model ?? "jina-embeddings-v3" });
+    const providerType = options.providerType ?? (interactive
+        ? await promptSelect("Embedding API type", [
+            { label: "jina", value: "jina" },
+            { label: "openai-compatible", value: "openai-compatible" }
+        ])
+        : undefined);
+    const queryTask = options.queryTask ?? (interactive && providerType === "jina"
+        ? await promptText("Query task", { defaultValue: existing?.queryTask ?? "retrieval.query" })
+        : undefined);
+    const passageTask = options.passageTask ?? (interactive && providerType === "jina"
+        ? await promptText("Passage task", { defaultValue: existing?.passageTask ?? "retrieval.passage" })
+        : undefined);
+    const dimensions = options.dimensions ?? null;
+    const config = await setMemoryEmbeddingConfig({
+        name,
+        baseUrl,
+        apiKey,
+        model,
+        providerType,
+        queryTask,
+        passageTask,
+        dimensions
+    });
+    console.log(`Configured memory embedding model: ${config.name} / ${config.model}`);
+    if (!options.skipTest) {
+        const result = await checkAndRecordMemoryEmbeddingConfig(config);
+        if (result.status === "ok") {
+            console.log(`Embedding check: ok (${result.dimensions} dimensions)`);
+        }
+        else {
+            console.log(`Embedding check: error (${result.error})`);
+        }
+    }
+    await writeLog({
+        category: "system",
+        action: "memory_embedding_config_set",
+        message: `Configured memory embedding model: ${config.name} / ${config.model}`,
+        metadata: { name: config.name, baseUrl: config.baseUrl, model: config.model, providerType: config.providerType }
+    });
+}
+async function testEmbeddingConfig(text = "ping") {
+    const config = await getMemoryEmbeddingConfig();
+    if (!config) {
+        console.log("No memory embedding model configured.");
+        console.log("Run `ai memory embedding set` first.");
+        return;
+    }
+    const result = await checkAndRecordMemoryEmbeddingConfig(config, text);
+    if (result.status === "ok") {
+        console.log(`Memory embedding check: ok`);
+        console.log(`Model: ${result.model}`);
+        console.log(`Dimensions: ${result.dimensions}`);
+        return;
+    }
+    console.log("Memory embedding check: error");
+    console.log(result.error);
+}
+async function clearEmbeddingConfig() {
+    const config = await getMemoryEmbeddingConfig();
+    if (!config) {
+        console.log("No memory embedding model configured.");
+        return;
+    }
+    const confirmed = await promptConfirm(`Clear memory embedding model ${config.name} / ${config.model}?`, false);
+    if (!confirmed) {
+        console.log("Clear cancelled.");
+        return;
+    }
+    await clearMemoryEmbeddingConfig();
+    console.log("Cleared memory embedding model config.");
+    await writeLog({
+        category: "system",
+        action: "memory_embedding_config_clear",
+        message: `Cleared memory embedding model config: ${config.name} / ${config.model}`,
+        metadata: { name: config.name, model: config.model }
+    });
+}
+function printEmbeddingConfig(config) {
+    console.log("Memory Embedding Model");
+    console.log("=".repeat(72));
+    console.log(`  Name       ${config.name}`);
+    console.log(`  Base URL   ${config.baseUrl}`);
+    console.log(`  API Key    ${maskSecret(config.apiKey)}`);
+    console.log(`  Type       ${config.providerType}`);
+    console.log(`  Model      ${config.model}`);
+    console.log(`  Query      ${config.queryTask ?? "(default)"}`);
+    console.log(`  Passage    ${config.passageTask ?? "(default)"}`);
+    console.log(`  Dims       ${config.dimensions ?? "(unknown)"}`);
+    console.log(`  Checked    ${config.lastCheckedAt ?? "(never)"}`);
+    if (config.lastError)
+        console.log(`  Error      ${config.lastError}`);
+}
+function parseSetOptions(args) {
+    const options = { skipTest: false };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--skip-test") {
+            options.skipTest = true;
+            continue;
+        }
+        if (arg === "--type" || arg === "--provider-type") {
+            options.providerType = parseProviderType(readOptionValue(args, index, arg));
+            index += 1;
+            continue;
+        }
+        if (arg === "--query-task") {
+            options.queryTask = readOptionValue(args, index, arg);
+            index += 1;
+            continue;
+        }
+        if (arg === "--passage-task") {
+            options.passageTask = readOptionValue(args, index, arg);
+            index += 1;
+            continue;
+        }
+        if (arg === "--dimensions") {
+            const dimensions = Number(readOptionValue(args, index, arg));
+            if (!Number.isInteger(dimensions) || dimensions <= 0) {
+                throw new Error("--dimensions must be a positive integer.");
+            }
+            options.dimensions = dimensions;
+            index += 1;
+        }
+    }
+    return options;
+}
+function parseSetPositionals(args) {
+    const values = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--skip-test")
+            continue;
+        if (arg.startsWith("--")) {
+            index += 1;
+            continue;
+        }
+        values.push(arg);
+    }
+    return values;
+}
+async function promptApiKey(existing) {
+    const message = existing ? "Embedding API key (leave blank to keep current)" : "Embedding API key";
+    const value = await promptText(message);
+    return value || existing || "";
+}
+function readOptionValue(args, index, option) {
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) {
+        throw new Error(`${option} requires a value.`);
+    }
+    return value;
+}
+function parseProviderType(value) {
+    if (value === "jina" || value === "openai-compatible")
+        return value;
+    throw new Error("--type must be jina or openai-compatible.");
+}

package/dist/cli/commands/report.js

@@ -0,0 +1,35 @@
+import { spawn } from "node:child_process";
+import { generateSessionReport } from "../../core/reports/report-service.js";
+import { listRecentSessions } from "../../core/sessions/session-service.js";
+import { promptSelect } from "../prompts/prompt.js";
+export async function runReportCommand(args) {
+    const shouldPrint = args.includes("--print");
+    const sessionId = args.find((arg) => arg !== "--print") ?? await selectSession();
+    const report = await generateSessionReport(sessionId);
+    if (shouldPrint) {
+        console.log(report.content);
+        return;
+    }
+    await openFile(report.filePath);
+    console.log(`Opened report file: ${report.filePath}`);
+}
+async function selectSession() {
+    const sessions = await listRecentSessions(20);
+    if (!sessions.length) {
+        throw new Error("No sessions found. Run `ai use` first.");
+    }
+    return promptSelect("Select session for report", sessions.map((session) => ({ label: formatSessionLabel(session), value: session.id })));
+}
+function formatSessionLabel(session) {
+    return `${session.startedAt}  ${session.tool}  ${session.provider}  ${session.model}  ${session.status}`;
+}
+async function openFile(filePath) {
+    const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", filePath] : [filePath];
+    await new Promise((resolve) => {
+        const child = spawn(opener, args, { stdio: "ignore", detached: true });
+        child.on("error", () => resolve());
+        child.on("close", () => resolve());
+        child.unref();
+    });
+}

package/dist/cli/commands/session.js

@@ -0,0 +1,74 @@
+import { clearAllSessions, getSession, listRecentSessions } from "../../core/sessions/session-service.js";
+import { writeLog } from "../../core/logs/log-service.js";
+import { promptSelect } from "../prompts/prompt.js";
+import { runUseCommand } from "./use.js";
+export async function runSessionCommand(args) {
+    const subcommand = args[0];
+    if (subcommand === "list") {
+        await printSessions();
+        return;
+    }
+    if (subcommand === "clear") {
+        await clearSessionsCommand();
+        return;
+    }
+    if (subcommand === "resume" && args[1]) {
+        await resumeSession(args[1]);
+        return;
+    }
+    if (subcommand && subcommand !== "list") {
+        throw new Error(`Unknown session command: ${subcommand}`);
+    }
+    await runSessionInteractive();
+}
+async function runSessionInteractive() {
+    const sessions = await listRecentSessions(20);
+    if (!sessions.length) {
+        console.log("No sessions found.");
+        return;
+    }
+    const sessionId = await promptSelect("Select session to resume", sessions.map((session) => ({ label: formatSessionLabel(session), value: session.id })));
+    await resumeSession(sessionId);
+}
+async function resumeSession(sessionId) {
+    const session = await getSession(sessionId);
+    if (!session) {
+        throw new Error(`Session not found: ${sessionId}`);
+    }
+    console.log(`Resuming ${session.tool}: ${session.provider} / ${session.model}`);
+    await runUseCommand([session.tool, session.provider, session.model]);
+}
+async function printSessions() {
+    const sessions = await listRecentSessions(20);
+    if (!sessions.length) {
+        console.log("No sessions found.");
+        return;
+    }
+    console.log(`AI Gateway Sessions (${sessions.length})`);
+    console.log("=".repeat(88));
+    sessions.forEach((session, index) => {
+        console.log(`${index + 1}. ${formatSessionLabel(session)}`);
+        console.log(`   id       ${session.id}`);
+        console.log(`   project  ${session.projectPath}`);
+        console.log(`   status   ${session.status}${session.exitCode === null ? "" : ` (${session.exitCode})`}`);
+        if (session.fallbackFrom) {
+            console.log(`   fallback ${session.fallbackFrom} -> ${session.provider}`);
+        }
+        if (index < sessions.length - 1) {
+            console.log("-".repeat(88));
+        }
+    });
+}
+async function clearSessionsCommand() {
+    const count = await clearAllSessions();
+    await writeLog({
+        category: "usage",
+        action: "sessions_cleared",
+        message: `Cleared ${count} session(s).`,
+        metadata: { count }
+    });
+    console.log(`Cleared ${count} session(s).`);
+}
+function formatSessionLabel(session) {
+    return `${session.startedAt}  ${session.tool}  ${session.provider}  ${session.model}`;
+}

package/dist/cli/commands/setup.js

@@ -0,0 +1,86 @@
+import { spawn } from "node:child_process";
+import { readProviders } from "../../core/config/providers-store.js";
+import { writeLog } from "../../core/logs/log-service.js";
+import { resolveToolCommand } from "../../core/runner/command-resolver.js";
+import { runDoctor } from "../../core/status/doctor-service.js";
+import { promptConfirm } from "../prompts/prompt.js";
+import { runAddCommand } from "./add.js";
+import { printDoctorItems } from "./doctor.js";
+const TOOL_PACKAGES = {
+    claude: "@anthropic-ai/claude-code",
+    codex: "@openai/codex"
+};
+export async function runSetupCommand(args) {
+    const yes = args.includes("--yes");
+    const installTools = args.includes("--install-tools");
+    const skipProvider = args.includes("--skip-provider");
+    const skipTools = args.includes("--skip-tools");
+    const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY) && !yes;
+    console.log("Preparing Axiom Runtime...");
+    const initialItems = await runDoctor({ fix: true, checkProviders: false });
+    printDoctorItems(initialItems);
+    let providers = await readProviders();
+    if (!providers.length && !skipProvider) {
+        const configureProvider = interactive
+            ? await promptConfirm("No provider is configured. Configure one now?", true)
+            : false;
+        if (configureProvider) {
+            await runAddCommand([]);
+            providers = await readProviders();
+        }
+        else {
+            console.log("Provider setup skipped. Run `ai provider add` when credentials are available.");
+        }
+    }
+    const missingTools = ["claude", "codex"].filter((tool) => !resolveToolCommand(tool));
+    if (missingTools.length && !skipTools) {
+        const authorized = installTools || (interactive && await promptConfirm(`Install missing CLIs (${missingTools.join(", ")}) with npm?`, false));
+        if (authorized) {
+            for (const tool of missingTools) {
+                try {
+                    await installTool(tool);
+                }
+                catch (error) {
+                    console.error(error instanceof Error ? error.message : String(error));
+                    console.error(`Install ${TOOL_PACKAGES[tool]} manually, then re-run \`ai doctor --local\`.`);
+                }
+            }
+        }
+        else {
+            console.log("External CLI installation skipped. Re-run with `ai setup --install-tools` to install them.");
+        }
+    }
+    const finalItems = await runDoctor({ fix: true, checkProviders: providers.length > 0 });
+    console.log("\nSetup result");
+    printDoctorItems(finalItems);
+    const errors = finalItems.filter((item) => item.status === "error").length;
+    const warnings = finalItems.filter((item) => item.status === "warn").length;
+    console.log(errors
+        ? `Setup completed with ${errors} error(s) and ${warnings} warning(s). Follow the suggested next steps above.`
+        : warnings
+            ? `Setup completed with ${warnings} optional warning(s).`
+            : "Setup completed. Axiom Runtime is ready.");
+    await writeLog({
+        category: "usage",
+        action: "setup",
+        message: `Setup completed with ${errors} error(s) and ${warnings} warning(s).`,
+        metadata: { errors, warnings, providerCount: providers.length, installTools, skipProvider, skipTools }
+    });
+}
+async function installTool(tool) {
+    const packageName = TOOL_PACKAGES[tool];
+    console.log(`Installing ${packageName}...`);
+    const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
+    const exitCode = await spawnInherited(npmCommand, ["install", "--global", packageName]);
+    if (exitCode !== 0) {
+        throw new Error(`Failed to install ${packageName} (exit code ${exitCode}).`);
+    }
+    console.log(`Installed ${packageName}.`);
+}
+function spawnInherited(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: "inherit" });
+        child.on("error", reject);
+        child.on("close", (code) => resolve(code ?? 1));
+    });
+}

package/dist/cli/commands/status.js

@@ -0,0 +1,50 @@
+import { getProviderStatuses } from "../../core/status/status-service.js";
+import { writeLog } from "../../core/logs/log-service.js";
+import { maskSecret } from "../output/table.js";
+export async function runStatusCommand() {
+    const statuses = await getProviderStatuses({ refresh: true });
+    await writeLog({
+        category: "usage",
+        action: "status_refresh",
+        message: `Refreshed ${statuses.length} provider(s) for status.`,
+        metadata: { providers: statuses.map((status) => ({ name: status.name, health: status.health, models: status.models.length })) }
+    });
+    printStatusCards(statuses);
+}
+function printStatusCards(statuses) {
+    if (!statuses.length) {
+        console.log("No providers configured. Run `ai add` first.");
+        return;
+    }
+    console.log(`AI Gateway Status (${statuses.length})`);
+    console.log("=".repeat(72));
+    statuses.forEach((status, index) => {
+        const isDefault = status.level === 1;
+        const title = `${status.level.toString().padStart(2, "0")}  ${status.name}${isDefault ? "  [default]" : ""}`;
+        const healthLine = `${title}  health:${status.health}  mode:${status.mode}`;
+        console.log(healthLine);
+        console.log("-".repeat(Math.min(72, Math.max(28, healthLine.length))));
+        printToolStatus("Claude", status.claude);
+        printToolStatus("Codex ", status.codex);
+        console.log(`  Config   ${status.baseUrl}`);
+        console.log(`  API Key  ${maskSecret(status.apiKey)}`);
+        console.log(`  Models   ${status.models.length}`);
+        console.log(`  Usage    ${status.weeklyTokens} weekly token(s), ${status.usageShare}% share`);
+        console.log(`  Checked  ${status.lastCheckedAt ?? "(never)"}`);
+        if (status.lastError) {
+            console.log(`  Error    ${status.lastError}`);
+        }
+        if (index < statuses.length - 1) {
+            console.log("");
+        }
+    });
+}
+function printToolStatus(label, status) {
+    const state = status.state === "ready" ? "ready" : status.state;
+    const model = status.model ?? "(none)";
+    console.log(`  ${label}  ${state}  ${model}`);
+    console.log(`          ${status.baseUrl}`);
+    if (status.state !== "ready") {
+        console.log(`          ${status.note}`);
+    }
+}