@offerpilot/axiomruntime 0.0.1

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

@@ -0,0 +1,114 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import lockfile from "proper-lockfile";
+const LOCK_OPTIONS = {
+    realpath: false,
+    stale: 10_000,
+    update: 5_000,
+    retries: {
+        retries: 100,
+        factor: 1.2,
+        minTimeout: 25,
+        maxTimeout: 500
+    }
+};
+export async function readJsonFile(filePath, fallback) {
+    try {
+        const raw = await fs.readFile(filePath, "utf8");
+        return parseJsonWithTrailingRecovery(raw);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return fallback;
+        }
+        throw error;
+    }
+}
+export async function writeJsonFile(filePath, value) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await withJsonFileLock(filePath, () => writeJsonFileUnlocked(filePath, value));
+}
+export async function updateJsonFile(filePath, fallback, updater) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    return withJsonFileLock(filePath, async () => {
+        const current = await readJsonFile(filePath, fallback);
+        const next = await updater(current);
+        await writeJsonFileUnlocked(filePath, next);
+        return next;
+    });
+}
+export async function withJsonFileLock(filePath, fn) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const release = await lockfile.lock(filePath, LOCK_OPTIONS);
+    try {
+        return await fn();
+    }
+    finally {
+        await release();
+    }
+}
+async function writeJsonFileUnlocked(filePath, value) {
+    const temporaryPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        await fs.writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+        await fs.rename(temporaryPath, filePath);
+    }
+    catch (error) {
+        await fs.rm(temporaryPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+function parseJsonWithTrailingRecovery(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (!(error instanceof SyntaxError))
+            throw error;
+        const prefix = extractFirstJsonValue(raw);
+        if (!prefix)
+            throw error;
+        return JSON.parse(prefix);
+    }
+}
+function extractFirstJsonValue(raw) {
+    const start = raw.search(/\S/);
+    if (start < 0)
+        return null;
+    const opener = raw[start];
+    const closer = opener === "{" ? "}" : opener === "[" ? "]" : "";
+    if (!closer)
+        return null;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = start; index < raw.length; index += 1) {
+        const char = raw[index];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === "\\") {
+                escaped = true;
+            }
+            else if (char === "\"") {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === "\"") {
+            inString = true;
+        }
+        else if (char === opener) {
+            depth += 1;
+        }
+        else if (char === closer) {
+            depth -= 1;
+            if (depth === 0) {
+                return raw.slice(start, index + 1);
+            }
+        }
+    }
+    return null;
+}

package/dist/core/config/paths.js

@@ -0,0 +1,85 @@
+import path from "node:path";
+import os from "node:os";
+export function getConfigRoot() {
+    return process.env.AI_GATEWAY_HOME
+        ? path.resolve(process.env.AI_GATEWAY_HOME)
+        : path.join(os.homedir(), ".ai-gateway");
+}
+export function getProjectRoot() {
+    return process.cwd();
+}
+export function getProvidersPath() {
+    return path.join(getConfigRoot(), "providers.json");
+}
+export function getCachePath() {
+    return path.join(getConfigRoot(), ".ai-cache.json");
+}
+export function getUsagePath() {
+    return path.join(getConfigRoot(), "usage.json");
+}
+export function getModelPricingPath() {
+    return path.join(getConfigRoot(), "model-pricing.json");
+}
+export function getSessionsPath() {
+    return path.join(getConfigRoot(), "sessions.json");
+}
+export function getIntegrationStatePath() {
+    return path.join(getConfigRoot(), "integrations.json");
+}
+export function getReportsDir() {
+    return path.join(getConfigRoot(), "reports");
+}
+export function getReportPath(sessionId) {
+    return path.join(getReportsDir(), `${sessionId}.md`);
+}
+export function getLogPath() {
+    return path.join(getConfigRoot(), ".ai-gateway.log");
+}
+export function getTelegramConfigPath() {
+    return path.join(getConfigRoot(), "telegram.json");
+}
+export function getTelegramPidPath() {
+    return path.join(getConfigRoot(), "telegram.pid");
+}
+export function getTelegramLogPath() {
+    return path.join(getConfigRoot(), "telegram.log");
+}
+export function getTelegramDbPath() {
+    return path.join(getConfigRoot(), "telegram.sqlite");
+}
+export function getTelegramBotDir() {
+    return path.join(getConfigRoot(), "telegram", "bots");
+}
+export function getTelegramBotConfigPath(name) {
+    return path.join(getTelegramBotDir(), `${name}.json`);
+}
+export function getTelegramBotPidPath(name) {
+    return path.join(getTelegramBotDir(), `${name}.pid`);
+}
+export function getTelegramBotLogPath(name) {
+    return path.join(getTelegramBotDir(), `${name}.log`);
+}
+export function getTelegramBotDbPath(name) {
+    return path.join(getTelegramBotDir(), `${name}.sqlite`);
+}
+export function getMemoryDbPath() {
+    return path.join(getConfigRoot(), "memory.sqlite");
+}
+export function getMemoryConfigPath() {
+    return path.join(getConfigRoot(), "memory.json");
+}
+export function getMemoryBackupDir() {
+    return path.join(getConfigRoot(), "memory.backup");
+}
+export function getContextDir() {
+    return path.join(getProjectRoot(), ".ai-gateway");
+}
+export function getContextPath() {
+    return path.join(getContextDir(), "context.md");
+}
+export function getContextPathForRoot(root) {
+    return path.join(root, ".ai-gateway", "context.md");
+}
+export function getUsageHtmlPath() {
+    return path.resolve(path.dirname(new URL(import.meta.url).pathname), "../../../docs/USAGE.html");
+}

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

@@ -0,0 +1,89 @@
+import { getProvidersPath } from "./paths.js";
+import { readJsonFile, updateJsonFile, writeJsonFile } from "./json-store.js";
+import { readNumber, readRecord, readString } from "./schema.js";
+const VALID_MODES = new Set(["ask", "auto"]);
+export async function readProviders() {
+    const raw = await readJsonFile(getProvidersPath(), []);
+    if (!Array.isArray(raw)) {
+        throw new Error("providers.json must contain a JSON array.");
+    }
+    return normalizeProviders(raw.map(normalizeProviderShape));
+}
+export async function writeProviders(providers) {
+    await writeJsonFile(getProvidersPath(), normalizeProviders(providers));
+}
+export async function updateProviders(updater) {
+    return updateJsonFile(getProvidersPath(), [], async (raw) => {
+        if (!Array.isArray(raw)) {
+            throw new Error("providers.json must contain a JSON array.");
+        }
+        return normalizeProviders(await updater(normalizeProviders(raw.map(normalizeProviderShape))));
+    });
+}
+export function normalizeProviders(providers) {
+    const sorted = [...providers].sort((a, b) => {
+        const aLevel = Number.isFinite(a.level) && a.level > 0 ? a.level : Number.MAX_SAFE_INTEGER;
+        const bLevel = Number.isFinite(b.level) && b.level > 0 ? b.level : Number.MAX_SAFE_INTEGER;
+        return aLevel - bLevel || a.name.localeCompare(b.name);
+    });
+    const seenNames = new Set();
+    return sorted.map((provider, index) => {
+        const name = provider.name.trim();
+        if (!name) {
+            throw new Error("Provider name cannot be empty.");
+        }
+        if (seenNames.has(name)) {
+            throw new Error(`Duplicate provider name: ${name}`);
+        }
+        seenNames.add(name);
+        const baseUrl = provider.baseUrl.trim().replace(/\/+$/, "");
+        const apiKey = provider.apiKey.trim();
+        if (!baseUrl) {
+            throw new Error(`Provider ${name} baseUrl cannot be empty.`);
+        }
+        if (!apiKey) {
+            throw new Error(`Provider ${name} apiKey cannot be empty.`);
+        }
+        return {
+            name,
+            baseUrl,
+            apiKey,
+            mode: VALID_MODES.has(provider.mode) ? provider.mode : "auto",
+            level: index + 1,
+            model: provider.model.trim()
+        };
+    });
+}
+export function swapProviderLevel(providers, providerName, targetLevel) {
+    const normalized = normalizeProviders(providers);
+    const source = normalized.find((provider) => provider.name === providerName);
+    if (!source) {
+        throw new Error(`Provider not found: ${providerName}`);
+    }
+    const target = normalized.find((provider) => provider.level === targetLevel);
+    if (!target) {
+        throw new Error(`Invalid level: ${targetLevel}`);
+    }
+    const sourceLevel = source.level;
+    return normalizeProviders(normalized.map((provider) => {
+        if (provider.name === source.name) {
+            return { ...provider, level: targetLevel };
+        }
+        if (provider.name === target.name) {
+            return { ...provider, level: sourceLevel };
+        }
+        return provider;
+    }));
+}
+function normalizeProviderShape(value) {
+    const provider = readRecord(value, "provider");
+    const mode = readString(provider, "mode");
+    return {
+        name: readString(provider, "name"),
+        baseUrl: readString(provider, "baseUrl"),
+        apiKey: readString(provider, "apiKey"),
+        mode: mode === "ask" ? "ask" : "auto",
+        level: readNumber(provider, "level", Number.MAX_SAFE_INTEGER),
+        model: readString(provider, "model")
+    };
+}

package/dist/core/config/schema.js

@@ -0,0 +1,60 @@
+import { isRecord } from "../utils/is-record.js";
+export class ConfigValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ConfigValidationError";
+    }
+}
+export function readRecord(value, path) {
+    if (!isRecord(value)) {
+        throw new ConfigValidationError(`${path} must be an object.`);
+    }
+    return value;
+}
+export function readOptionalRecord(value, path) {
+    if (value === null || value === undefined)
+        return undefined;
+    return readRecord(value, path);
+}
+export function readString(record, key, options = {}) {
+    const value = record[key] ?? options.fallback ?? "";
+    const text = String(value);
+    return options.trim === false ? text : text.trim();
+}
+export function readRequiredString(record, key, path = key) {
+    const value = readString(record, key);
+    if (!value) {
+        throw new ConfigValidationError(`${path} cannot be empty.`);
+    }
+    return value;
+}
+export function readOptionalString(record, key) {
+    const value = record[key];
+    if (value === null || value === undefined)
+        return undefined;
+    const text = String(value).trim();
+    return text || undefined;
+}
+export function readNumber(record, key, fallback) {
+    const value = Number(record[key] ?? fallback);
+    return Number.isFinite(value) ? value : fallback;
+}
+export function readEnum(record, key, values, fallback) {
+    const value = String(record[key] ?? fallback);
+    return values.includes(value) ? value : fallback;
+}
+export function readBoolean(value) {
+    if (typeof value === "boolean")
+        return value;
+    const text = String(value ?? "").trim().toLowerCase();
+    return text === "true" || text === "1" || text === "yes" || text === "y" || text === "on";
+}
+export function readArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+export function readRequiredArray(value, path) {
+    if (!Array.isArray(value)) {
+        throw new ConfigValidationError(`${path} must be an array.`);
+    }
+    return value;
+}

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

@@ -0,0 +1,30 @@
+import { getSessionsPath } from "./paths.js";
+import { readJsonFile, updateJsonFile, writeJsonFile } from "./json-store.js";
+export async function readSessions() {
+    const file = await readJsonFile(getSessionsPath(), { sessions: [] });
+    return normalizeSessionsFile(file);
+}
+export async function writeSessions(file) {
+    await writeJsonFile(getSessionsPath(), normalizeSessionsFile(file));
+}
+export async function addSession(session) {
+    await updateJsonFile(getSessionsPath(), { sessions: [] }, (file) => ({
+        sessions: [...normalizeSessionsFile(file).sessions, session]
+    }));
+}
+export async function updateSession(sessionId, patch) {
+    await updateJsonFile(getSessionsPath(), { sessions: [] }, (file) => ({
+        sessions: normalizeSessionsFile(file).sessions.map((session) => session.id === sessionId ? { ...session, ...patch } : session)
+    }));
+}
+export async function clearSessions() {
+    let count = 0;
+    await updateJsonFile(getSessionsPath(), { sessions: [] }, (file) => {
+        count = normalizeSessionsFile(file).sessions.length;
+        return { sessions: [] };
+    });
+    return count;
+}
+function normalizeSessionsFile(file) {
+    return { sessions: Array.isArray(file.sessions) ? file.sessions : [] };
+}

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

@@ -0,0 +1,18 @@
+import { getUsagePath } from "./paths.js";
+import { readJsonFile, updateJsonFile, writeJsonFile } from "./json-store.js";
+export async function readUsage() {
+    const usage = await readJsonFile(getUsagePath(), { events: [] });
+    return normalizeUsageFile(usage);
+}
+export async function appendUsageEvent(event) {
+    await updateJsonFile(getUsagePath(), { events: [] }, (usage) => ({
+        events: [...normalizeUsageFile(usage).events, event]
+    }));
+}
+export async function ensureUsageFile() {
+    const usage = await readUsage();
+    await writeJsonFile(getUsagePath(), usage);
+}
+function normalizeUsageFile(usage) {
+    return { events: Array.isArray(usage.events) ? usage.events : [] };
+}

package/dist/core/context/context-service.js

@@ -0,0 +1,186 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { getContextPathForRoot, getProjectRoot } from "../config/paths.js";
+import { readRecentLogs } from "../logs/log-service.js";
+const execFileAsync = promisify(execFile);
+const EXCLUDED_DIRS = new Set([
+    ".git",
+    ".ai-gateway",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    ".next",
+    ".turbo",
+    ".cache"
+]);
+const EXCLUDED_FILES = new Set([
+    "providers.json",
+    ".ai-cache.json",
+    "usage.json",
+    ".ai-gateway.log",
+    ".DS_Store",
+    ".env"
+]);
+const DOC_CANDIDATES = [
+    "README.md",
+    "AGENTS.md",
+    "CLAUDE.md",
+    "docs/00-overview.md",
+    "docs/CONVENTIONS.md",
+    "docs/usage.md"
+];
+export async function generateProjectContext(root = getProjectRoot()) {
+    const content = [
+        "# AI Gateway Project Context",
+        "",
+        `Generated at: ${new Date().toISOString()}`,
+        `Project root: ${root}`,
+        "",
+        await renderGitSection(root),
+        await renderPackageSection(root),
+        await renderFileTree(root),
+        await renderDocsSection(root),
+        await renderLogsSection()
+    ].join("\n");
+    const filePath = getContextPathForRoot(root);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, `${content.trim()}\n`, "utf8");
+    return { filePath, content: `${content.trim()}\n` };
+}
+async function renderGitSection(root) {
+    const [branch, status, diffStat, latestCommit] = await Promise.all([
+        runGit(root, ["branch", "--show-current"]),
+        runGit(root, ["status", "--short"]),
+        runGit(root, ["diff", "--stat"]),
+        runGit(root, ["log", "-1", "--oneline"])
+    ]);
+    return [
+        "## Git",
+        "",
+        `Branch: ${branch || "(unknown)"}`,
+        `Latest commit: ${latestCommit || "(none)"}`,
+        "",
+        "### Status",
+        "",
+        fenced(status || "clean"),
+        "",
+        "### Diff Stat",
+        "",
+        fenced(diffStat || "no working tree diff")
+    ].join("\n");
+}
+async function renderPackageSection(root) {
+    const packagePath = path.join(root, "package.json");
+    try {
+        const pkg = JSON.parse(await fs.readFile(packagePath, "utf8"));
+        const scripts = Object.entries(pkg.scripts ?? {})
+            .map(([name, script]) => `- ${name}: ${script}`)
+            .join("\n") || "- none";
+        return [
+            "## Project",
+            "",
+            `Name: ${pkg.name ?? "(unknown)"}`,
+            `Version: ${pkg.version ?? "(unknown)"}`,
+            `Type: ${pkg.type ?? "(unknown)"}`,
+            "",
+            "### Scripts",
+            "",
+            scripts
+        ].join("\n");
+    }
+    catch {
+        return ["## Project", "", "No package.json detected."].join("\n");
+    }
+}
+async function renderFileTree(root) {
+    const entries = await collectTree(root, root, 0, 3, 180);
+    return [
+        "## File Tree",
+        "",
+        "Excluded: node_modules, dist, build, .git, .ai-gateway, env/key/cache files.",
+        "",
+        fenced(entries.join("\n") || "(empty)")
+    ].join("\n");
+}
+async function renderDocsSection(root) {
+    const sections = ["## Key Documents", ""];
+    for (const relativePath of DOC_CANDIDATES) {
+        const absolutePath = path.join(root, relativePath);
+        const text = await readTextIfExists(absolutePath);
+        if (!text)
+            continue;
+        sections.push(`### ${relativePath}`, "", truncate(text, 1600), "");
+    }
+    if (sections.length === 2) {
+        sections.push("No key documents found.");
+    }
+    return sections.join("\n").trimEnd();
+}
+async function renderLogsSection() {
+    const logs = await readRecentLogs(10);
+    return [
+        "## Recent AI Gateway Logs",
+        "",
+        logs.length
+            ? logs.map((event) => `- ${event.timestamp} [${event.level}] ${event.category}/${event.action}: ${event.message}`).join("\n")
+            : "No logs found."
+    ].join("\n");
+}
+async function collectTree(root, current, depth, maxDepth, maxEntries, state = { count: 0 }) {
+    if (depth > maxDepth || state.count >= maxEntries)
+        return [];
+    const dirents = await fs.readdir(current, { withFileTypes: true });
+    const lines = [];
+    for (const dirent of dirents.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (state.count >= maxEntries)
+            break;
+        if (shouldExclude(dirent.name))
+            continue;
+        const absolutePath = path.join(current, dirent.name);
+        const relativePath = path.relative(root, absolutePath);
+        lines.push(`${"  ".repeat(depth)}${dirent.isDirectory() ? "+ " : "- "}${relativePath}`);
+        state.count += 1;
+        if (dirent.isDirectory()) {
+            lines.push(...await collectTree(root, absolutePath, depth + 1, maxDepth, maxEntries, state));
+        }
+    }
+    return lines;
+}
+function shouldExclude(name) {
+    if (EXCLUDED_DIRS.has(name) || EXCLUDED_FILES.has(name))
+        return true;
+    if (name.endsWith(".log"))
+        return true;
+    if (name.endsWith(".pem") || name.endsWith(".key") || name.endsWith(".p12"))
+        return true;
+    return false;
+}
+async function runGit(cwd, args) {
+    try {
+        const { stdout } = await execFileAsync("git", args, { cwd });
+        return stdout.trim();
+    }
+    catch {
+        return "";
+    }
+}
+async function readTextIfExists(filePath) {
+    try {
+        return await fs.readFile(filePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function truncate(value, maxLength) {
+    const trimmed = value.trim();
+    if (trimmed.length <= maxLength)
+        return trimmed;
+    return `${trimmed.slice(0, maxLength)}\n\n... truncated ...`;
+}
+function fenced(value) {
+    return `\`\`\`text\n${value}\n\`\`\``;
+}

package/dist/core/integrations/integration-state.js

@@ -0,0 +1,105 @@
+import { getIntegrationStatePath } from "../config/paths.js";
+import { readJsonFile, updateJsonFile, writeJsonFile } from "../config/json-store.js";
+const EMPTY_STATE = {
+    providerRevision: 0,
+    integrations: {}
+};
+const registeredIntegrations = new Set();
+export async function readIntegrationState() {
+    const raw = await readJsonFile(getIntegrationStatePath(), EMPTY_STATE);
+    return normalizeIntegrationState(raw);
+}
+export async function writeIntegrationState(state) {
+    await writeJsonFile(getIntegrationStatePath(), normalizeIntegrationState(state));
+}
+export async function recordProviderChange(change) {
+    return updateJsonFile(getIntegrationStatePath(), EMPTY_STATE, (raw) => {
+        const state = normalizeIntegrationState(raw);
+        const nextRevision = state.providerRevision + 1;
+        const providerChange = { ...change, at: new Date().toISOString() };
+        const integrations = { ...state.integrations };
+        for (const name of registeredIntegrations) {
+            integrations[name] = appendProviderChange(getIntegrationProviderState(state, name), providerChange);
+        }
+        return {
+            providerRevision: nextRevision,
+            integrations
+        };
+    });
+}
+export async function markIntegrationProvidersSynced(integrationName) {
+    const name = normalizeIntegrationName(integrationName);
+    await updateJsonFile(getIntegrationStatePath(), EMPTY_STATE, (raw) => {
+        const state = normalizeIntegrationState(raw);
+        const synced = {
+            syncedProviderRevision: state.providerRevision,
+            pendingProviderChanges: []
+        };
+        const integrations = { ...state.integrations, [name]: synced };
+        return {
+            providerRevision: state.providerRevision,
+            integrations
+        };
+    });
+}
+export async function hasPendingProviderChanges(integrationName) {
+    const state = await readIntegrationState();
+    const integration = getIntegrationProviderState(state, integrationName);
+    return state.providerRevision !== integration.syncedProviderRevision || integration.pendingProviderChanges.length > 0;
+}
+export function registerIntegration(registration) {
+    registeredIntegrations.add(normalizeIntegrationName(registration.name));
+}
+export function getIntegrationProviderState(state, integrationName) {
+    const name = normalizeIntegrationName(integrationName);
+    return state.integrations[name] ?? {
+        syncedProviderRevision: state.providerRevision,
+        pendingProviderChanges: []
+    };
+}
+function normalizeIntegrationState(value) {
+    const integrations = normalizeIntegrationMap(value.integrations);
+    return {
+        providerRevision: Number(value.providerRevision ?? 0),
+        integrations
+    };
+}
+function normalizeIntegrationMap(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return {};
+    const integrations = {};
+    for (const [name, raw] of Object.entries(value)) {
+        const normalizedName = normalizeIntegrationName(name);
+        integrations[normalizedName] = normalizeIntegrationProviderSyncState(raw);
+    }
+    return integrations;
+}
+function normalizeIntegrationProviderSyncState(value) {
+    return {
+        syncedProviderRevision: Number(value.syncedProviderRevision ?? 0),
+        pendingProviderChanges: Array.isArray(value.pendingProviderChanges)
+            ? value.pendingProviderChanges.filter(isProviderChange)
+            : []
+    };
+}
+function appendProviderChange(state, change) {
+    return {
+        syncedProviderRevision: state.syncedProviderRevision,
+        pendingProviderChanges: [...state.pendingProviderChanges, change]
+    };
+}
+function normalizeIntegrationName(value) {
+    const name = value.trim();
+    if (!name) {
+        throw new Error("Integration name cannot be empty.");
+    }
+    return name;
+}
+function isProviderChange(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const change = value;
+    return (change.type === "added" || change.type === "updated" || change.type === "deleted")
+        && typeof change.provider === "string"
+        && typeof change.at === "string";
+}