@offerpilot/axiomruntime 0.0.1

package/dist/core/logs/log-service.js

@@ -0,0 +1,56 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getLogPath } from "../config/paths.js";
+export async function writeLog(input) {
+    const event = {
+        timestamp: new Date().toISOString(),
+        level: input.level ?? "info",
+        category: input.category,
+        action: input.action,
+        message: input.message,
+        metadata: input.metadata
+    };
+    try {
+        const filePath = getLogPath();
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.appendFile(filePath, `${JSON.stringify(event)}\n`, "utf8");
+    }
+    catch {
+        // Logging must never break the user command.
+    }
+}
+export async function readRecentLogs(limit = 50) {
+    try {
+        const raw = await fs.readFile(getLogPath(), "utf8");
+        const events = raw
+            .split("\n")
+            .filter(Boolean)
+            .map(parseLogLine)
+            .filter((event) => Boolean(event));
+        return events.slice(-limit);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+}
+export async function ensureLogFile() {
+    const filePath = getLogPath();
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.appendFile(filePath, "", "utf8");
+    return filePath;
+}
+function parseLogLine(line) {
+    try {
+        const value = JSON.parse(line);
+        if (!value.timestamp || !value.level || !value.category || !value.action || !value.message) {
+            return null;
+        }
+        return value;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/core/memory/embedding-check.js

@@ -0,0 +1,121 @@
+import { updateMemoryEmbeddingCheck } from "./memory-config.js";
+export async function checkMemoryEmbeddingConfig(config, text = "ping", inputKind = "query") {
+    const checkedAt = new Date().toISOString();
+    try {
+        const response = await fetchWithTimeout(buildEmbeddingsUrl(config.baseUrl), {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${config.apiKey}`,
+                "Content-Type": "application/json",
+                Accept: "application/json"
+            },
+            body: JSON.stringify(buildEmbeddingPayload(config, text, inputKind))
+        });
+        const raw = await response.text();
+        const json = parseJson(raw);
+        const embedding = readEmbedding(json);
+        if (!response.ok) {
+            return {
+                status: "error",
+                model: config.model,
+                dimensions: null,
+                checkedAt,
+                error: `POST embeddings failed with ${response.status} ${response.statusText}${extractErrorMessage(json)}`
+            };
+        }
+        if (!embedding) {
+            return {
+                status: "error",
+                model: config.model,
+                dimensions: null,
+                checkedAt,
+                error: "Embedding response did not include data[0].embedding."
+            };
+        }
+        return {
+            status: "ok",
+            model: config.model,
+            dimensions: embedding.length,
+            checkedAt,
+            error: null
+        };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            model: config.model,
+            dimensions: null,
+            checkedAt,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+export async function checkAndRecordMemoryEmbeddingConfig(config, text, inputKind) {
+    const result = await checkMemoryEmbeddingConfig(config, text, inputKind);
+    await updateMemoryEmbeddingCheck({
+        dimensions: result.dimensions,
+        checkedAt: result.checkedAt,
+        error: result.error
+    });
+    return result;
+}
+function buildEmbeddingsUrl(baseUrl) {
+    const normalized = baseUrl.replace(/\/+$/, "");
+    return normalized.endsWith("/embeddings") ? normalized : `${normalized}/embeddings`;
+}
+function buildEmbeddingPayload(config, text, inputKind) {
+    const payload = {
+        model: config.model,
+        input: [text]
+    };
+    if (config.providerType === "jina") {
+        const task = inputKind === "query" ? config.queryTask : config.passageTask;
+        if (task)
+            payload.task = task;
+    }
+    return payload;
+}
+function readEmbedding(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const data = value.data;
+    if (!Array.isArray(data) || !data[0] || typeof data[0] !== "object")
+        return null;
+    const embedding = data[0].embedding;
+    if (!Array.isArray(embedding) || !embedding.length)
+        return null;
+    return embedding.every((item) => typeof item === "number") ? embedding : null;
+}
+function parseJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function extractErrorMessage(value) {
+    if (!value || typeof value !== "object")
+        return "";
+    const data = value;
+    const error = data.error;
+    if (typeof error === "string")
+        return `: ${error}`;
+    if (error && typeof error === "object") {
+        const message = error.message;
+        if (typeof message === "string")
+            return `: ${message}`;
+    }
+    const message = data.message;
+    return typeof message === "string" ? `: ${message}` : "";
+}
+async function fetchWithTimeout(url, init, timeoutMs = 12_000) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/core/memory/memory-config.js

@@ -0,0 +1,122 @@
+import { getMemoryConfigPath } from "../config/paths.js";
+import { readJsonFile, updateJsonFile, writeJsonFile } from "../config/json-store.js";
+import { readNumber, readOptionalString, readRecord, readString } from "../config/schema.js";
+const DEFAULT_MEMORY_CONFIG = {
+    embedding: null
+};
+const VALID_PROVIDER_TYPES = new Set(["openai-compatible", "jina"]);
+export async function readMemoryConfig() {
+    return normalizeMemoryConfig(await readJsonFile(getMemoryConfigPath(), DEFAULT_MEMORY_CONFIG));
+}
+export async function writeMemoryConfig(config) {
+    await writeJsonFile(getMemoryConfigPath(), normalizeMemoryConfig(config));
+}
+export async function getMemoryEmbeddingConfig() {
+    return (await readMemoryConfig()).embedding;
+}
+export async function setMemoryEmbeddingConfig(input) {
+    const next = normalizeMemoryEmbeddingConfig({
+        enabled: true,
+        name: input.name,
+        baseUrl: input.baseUrl,
+        apiKey: input.apiKey,
+        model: input.model,
+        providerType: input.providerType ?? inferProviderType(input.name, input.baseUrl, input.model),
+        queryTask: input.queryTask,
+        passageTask: input.passageTask,
+        dimensions: input.dimensions ?? null,
+        updatedAt: new Date().toISOString(),
+        lastCheckedAt: null,
+        lastError: null
+    });
+    await updateJsonFile(getMemoryConfigPath(), DEFAULT_MEMORY_CONFIG, (current) => ({
+        ...normalizeMemoryConfig(current),
+        embedding: next
+    }));
+    return next;
+}
+export async function updateMemoryEmbeddingCheck(result) {
+    const updated = await updateJsonFile(getMemoryConfigPath(), DEFAULT_MEMORY_CONFIG, (current) => {
+        const normalized = normalizeMemoryConfig(current);
+        if (!normalized.embedding)
+            return normalized;
+        return {
+            ...normalized,
+            embedding: {
+                ...normalized.embedding,
+                dimensions: result.dimensions ?? normalized.embedding.dimensions,
+                lastCheckedAt: result.checkedAt,
+                lastError: result.error
+            }
+        };
+    });
+    return updated.embedding;
+}
+export async function clearMemoryEmbeddingConfig() {
+    const previous = await readMemoryConfig();
+    await updateJsonFile(getMemoryConfigPath(), DEFAULT_MEMORY_CONFIG, (current) => ({
+        ...normalizeMemoryConfig(current),
+        embedding: null
+    }));
+    return previous.embedding !== null;
+}
+export function normalizeMemoryConfig(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return DEFAULT_MEMORY_CONFIG;
+    }
+    const record = value;
+    return {
+        embedding: record.embedding ? normalizeMemoryEmbeddingConfig(record.embedding) : null
+    };
+}
+function normalizeMemoryEmbeddingConfig(value) {
+    const record = readRecord(value, "memory.embedding");
+    const name = readString(record, "name");
+    const baseUrl = readString(record, "baseUrl").replace(/\/+$/, "");
+    const apiKey = readString(record, "apiKey");
+    const model = readString(record, "model");
+    if (!name)
+        throw new Error("Memory embedding provider name cannot be empty.");
+    if (!baseUrl)
+        throw new Error("Memory embedding baseUrl cannot be empty.");
+    if (!apiKey)
+        throw new Error("Memory embedding apiKey cannot be empty.");
+    if (!model)
+        throw new Error("Memory embedding model cannot be empty.");
+    const rawProviderType = readString(record, "providerType", {
+        fallback: inferProviderType(name, baseUrl, model)
+    });
+    const providerType = VALID_PROVIDER_TYPES.has(rawProviderType)
+        ? rawProviderType
+        : inferProviderType(name, baseUrl, model);
+    const queryTask = readOptionalString(record, "queryTask") ?? defaultQueryTask(providerType);
+    const passageTask = readOptionalString(record, "passageTask") ?? defaultPassageTask(providerType);
+    const dimensions = normalizeDimensions(readNumber(record, "dimensions", 0));
+    return {
+        enabled: record.enabled === false ? false : true,
+        name,
+        baseUrl,
+        apiKey,
+        model,
+        providerType,
+        ...(queryTask ? { queryTask } : {}),
+        ...(passageTask ? { passageTask } : {}),
+        dimensions,
+        updatedAt: readString(record, "updatedAt", { fallback: new Date().toISOString() }),
+        lastCheckedAt: readOptionalString(record, "lastCheckedAt") ?? null,
+        lastError: readOptionalString(record, "lastError") ?? null
+    };
+}
+function inferProviderType(name, baseUrl, model) {
+    const value = `${name} ${baseUrl} ${model}`.toLowerCase();
+    return value.includes("jina") ? "jina" : "openai-compatible";
+}
+function defaultQueryTask(providerType) {
+    return providerType === "jina" ? "retrieval.query" : undefined;
+}
+function defaultPassageTask(providerType) {
+    return providerType === "jina" ? "retrieval.passage" : undefined;
+}
+function normalizeDimensions(value) {
+    return Number.isInteger(value) && value > 0 ? value : null;
+}