@memorax/memorax-code 0.1.0

package/lib/memorax-code-backend/dist/memorax-code-config.js

@@ -0,0 +1,279 @@
+import { readFileSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { parse } from "smol-toml";
+import { ensurePrivateConfigDirectory } from "../../memorax-code-adapter-common/src/memorax-code-config-file.mjs";
+import { MEMORAX_DEFAULT_BASE_URL, MEMORAX_DEFAULT_MEMORY_OUTPUT_LANGUAGE, } from "../../memorax-code-adapter-common/src/memorax-defaults.mjs";
+export function defaultMemoraxCodeHome(env = process.env) {
+    return env.MEMORAX_CODE_HOME?.trim() || join(homedir(), ".memorax-code");
+}
+export function memoraxCodeConfigPath(memoraxCodeHome = defaultMemoraxCodeHome(process.env)) {
+    return join(memoraxCodeHome, "config.toml");
+}
+export function renderDefaultMemoraxCodeConfig() {
+    return [
+        "# MemoraX Code local config.",
+        "# This file is read from $MEMORAX_CODE_HOME/config.toml.",
+        "# Environment variables still override values written here.",
+        "# See docs/configuration.md for advanced tuning fields and effective defaults.",
+        "",
+        "# Client integrations managed by `memorax-code start|status|stop|uninstall`.",
+        "[clients]",
+        "codex = true",
+        "claude = true",
+        "",
+        "# MemoraX remote-memory connection. Credentials may also come from the environment.",
+        "[memorax]",
+        `# endpoint = "${MEMORAX_DEFAULT_BASE_URL}" # MemoraX service URL.`,
+        '# api_key = "" # MemoraX API key used by the local Backend.',
+        '# user_id = "" # MemoraX base user ID; requests derive a workspace-scoped namespace.',
+        "",
+        "# Automatic Hook retrieval is opt-in.",
+        "[memory.retrieval]",
+        "enabled = false # Auto-inject retrieved memories into supported client prompts.",
+        "",
+        "# Automatic writeback sends selected prompts and final answers to MemoraX.",
+        "[memory.writeback]",
+        "enabled = true # Allow supported client sessions to write memories after replies.",
+        "",
+        "# Preferred language for newly generated MemoraX memories.",
+        "[memory.add]",
+        `output_language = "${MEMORAX_DEFAULT_MEMORY_OUTPUT_LANGUAGE}" # Language for newly generated MemoraX memories.`,
+        "",
+        "# Controls how often Codex and Claude Code native client sessions see the MemoraX Code skill reminder.",
+        "[memory.skill_reminder]",
+        "interval_turns = 5 # Show the MemoraX Code skill reminder every N native client turns, starting on the first turn.",
+        "",
+        "# Relevant repo reads batch generated repo-memory updates by commit count or elapsed time.",
+        "[memory.repo_update]",
+        'policy = "adaptive" # every-commit / commit-count / daily / pull-request / pull-request-or-daily / adaptive.',
+        "commit_threshold = 5 # Pending local commits needed by commit-count and adaptive.",
+        "cooldown_hours = 24 # Pending-commit age used by daily, pull-request-or-daily, and adaptive.",
+        "",
+        "# Local traces may contain prompts, responses, recalled memories, and local paths.",
+        "[trace.codex]",
+        "enabled = true # Enable local Codex session memory trace collection.",
+        "capture_content = true # Store content in local Codex trace events.",
+        "",
+        "[trace.claude]",
+        "enabled = true # Enable local Claude session memory trace collection.",
+        "capture_content = true # Store content in local Claude trace events.",
+        "",
+    ].join("\n");
+}
+export async function seedMissingMemoraxCodeConfig(memoraxCodeHome = defaultMemoraxCodeHome(process.env)) {
+    const path = memoraxCodeConfigPath(memoraxCodeHome);
+    ensurePrivateConfigDirectory(path);
+    try {
+        await writeFile(path, renderDefaultMemoraxCodeConfig(), {
+            encoding: "utf8",
+            flag: "wx",
+            mode: 0o600,
+        });
+        return true;
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "EEXIST")
+            return false;
+        throw error;
+    }
+}
+export function loadMemoraxCodeConfig(memoraxCodeHome = defaultMemoraxCodeHome(process.env), options = {}) {
+    const path = memoraxCodeConfigPath(memoraxCodeHome);
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT")
+            return {};
+        (options.warn ?? console.warn)(`failed to read MemoraX Code config ${path}: ${errorMessage(error)}`);
+        return {};
+    }
+    try {
+        return normalizeMemoraxCodeConfig(parse(text));
+    }
+    catch (error) {
+        (options.warn ?? console.warn)(`failed to parse MemoraX Code config ${path}: ${errorMessage(error)}`);
+        return {};
+    }
+}
+export function loadLifecycleMemoraxCodeConfig(memoraxCodeHome = defaultMemoraxCodeHome(process.env)) {
+    const path = memoraxCodeConfigPath(memoraxCodeHome);
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT")
+            return {};
+        throw new Error(`failed to read MemoraX Code lifecycle config ${path}: ${errorMessage(error)}`);
+    }
+    let parsed;
+    try {
+        parsed = parse(text);
+    }
+    catch {
+        throw new Error(`failed to parse MemoraX Code lifecycle config ${path}`);
+    }
+    validateRawLifecycleConfig(parsed, path);
+    return normalizeMemoraxCodeConfig(parsed);
+}
+function normalizeMemoraxCodeConfig(value) {
+    const root = recordValue(value);
+    const clients = recordValue(root?.clients);
+    const memorax = recordValue(root?.memorax);
+    const memory = recordValue(root?.memory);
+    const trace = recordValue(root?.trace);
+    const retrieval = recordValue(memory?.retrieval);
+    const writeback = recordValue(memory?.writeback);
+    const add = recordValue(memory?.add);
+    const cli = recordValue(memory?.cli);
+    const skillReminder = recordValue(memory?.skill_reminder);
+    const repoUpdate = recordValue(memory?.repo_update);
+    const traceCodex = recordValue(trace?.codex);
+    const traceClaude = recordValue(trace?.claude);
+    return (prune({
+        clients: prune({
+            codex: booleanField(clients, "codex"),
+            claude: booleanField(clients, "claude"),
+        }),
+        memorax: prune({
+            endpoint: stringField(memorax, "endpoint"),
+            api_key: stringField(memorax, "api_key"),
+            user_id: stringField(memorax, "user_id"),
+            timeout_ms: numberField(memorax, "timeout_ms"),
+            startup_timeout_ms: numberField(memorax, "startup_timeout_ms"),
+        }),
+        memory: prune({
+            retrieval: prune({
+                enabled: booleanField(retrieval, "enabled"),
+                top_k: numberField(retrieval, "top_k"),
+                k_dense: numberField(retrieval, "k_dense"),
+                k_sparse: numberField(retrieval, "k_sparse"),
+                min_score: numberField(retrieval, "min_score"),
+                max_context_chars: numberField(retrieval, "max_context_chars"),
+                max_item_chars: numberField(retrieval, "max_item_chars"),
+                render_by_memory_type: booleanField(retrieval, "render_by_memory_type"),
+                memory_type_order: stringArrayField(retrieval, "memory_type_order"),
+            }),
+            writeback: prune({
+                enabled: booleanField(writeback, "enabled"),
+                buffer_enabled: booleanField(writeback, "buffer_enabled"),
+                buffer_max_turns: numberField(writeback, "buffer_max_turns"),
+                buffer_max_age_ms: numberField(writeback, "buffer_max_age_ms"),
+                buffer_max_chars: numberField(writeback, "buffer_max_chars"),
+                max_message_chars: numberField(writeback, "max_message_chars"),
+                chunk_enabled: booleanField(writeback, "chunk_enabled"),
+                chunk_max_chars: numberField(writeback, "chunk_max_chars"),
+                chunk_overlap_ratio: numberField(writeback, "chunk_overlap_ratio"),
+            }),
+            add: prune({
+                content_type: stringField(add, "content_type"),
+                mode: stringField(add, "mode"),
+                output_language: stringField(add, "output_language"),
+            }),
+            cli: prune({
+                add_enabled: booleanField(cli, "add_enabled"),
+                max_memory_chars: numberField(cli, "max_memory_chars"),
+            }),
+            skill_reminder: prune({
+                interval_turns: numberField(skillReminder, "interval_turns"),
+            }),
+            repo_update: prune({
+                policy: repoMemoryUpdatePolicyField(repoUpdate, "policy"),
+                commit_threshold: numberField(repoUpdate, "commit_threshold"),
+                cooldown_hours: numberField(repoUpdate, "cooldown_hours"),
+            }),
+        }),
+        trace: prune({
+            codex: prune({
+                enabled: booleanField(traceCodex, "enabled"),
+                capture_content: booleanField(traceCodex, "capture_content"),
+                retention_days: numberField(traceCodex, "retention_days"),
+                max_event_chars: numberField(traceCodex, "max_event_chars"),
+                max_file_bytes: numberField(traceCodex, "max_file_bytes"),
+            }),
+            claude: prune({
+                enabled: booleanField(traceClaude, "enabled"),
+                capture_content: booleanField(traceClaude, "capture_content"),
+                retention_days: numberField(traceClaude, "retention_days"),
+                max_event_chars: numberField(traceClaude, "max_event_chars"),
+                max_file_bytes: numberField(traceClaude, "max_file_bytes"),
+            }),
+        }),
+    }) ?? {});
+}
+function validateRawLifecycleConfig(value, path) {
+    const root = tableValue(value);
+    if (!root)
+        throw invalidLifecycleConfig(path, "config root must be a table");
+    const rawClients = root.clients;
+    if (rawClients !== undefined) {
+        const clients = tableValue(rawClients);
+        if (!clients)
+            throw invalidLifecycleConfig(path, "clients must be a table");
+        for (const field of ["codex", "claude"]) {
+            if (clients[field] !== undefined && typeof clients[field] !== "boolean") {
+                throw invalidLifecycleConfig(path, `clients.${field} must be a boolean`);
+            }
+        }
+    }
+}
+function invalidLifecycleConfig(path, detail) {
+    return new Error(`invalid MemoraX Code lifecycle config ${path}: ${detail}`);
+}
+function tableValue(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null
+        ? value
+        : undefined;
+}
+function recordValue(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringField(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" && value.trim() ? value : undefined;
+}
+function repoMemoryUpdatePolicyField(record, key) {
+    const value = stringField(record, key);
+    return value === "every-commit"
+        || value === "commit-count"
+        || value === "daily"
+        || value === "pull-request"
+        || value === "pull-request-or-daily"
+        || value === "adaptive"
+        ? value
+        : undefined;
+}
+function numberField(record, key) {
+    const value = record?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function booleanField(record, key) {
+    const value = record?.[key];
+    return typeof value === "boolean" ? value : undefined;
+}
+function stringArrayField(record, key) {
+    const value = record?.[key];
+    if (!Array.isArray(value))
+        return undefined;
+    const items = value.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean);
+    return items.length ? items : undefined;
+}
+function prune(values) {
+    const entries = Object.entries(values).filter(([, value]) => value !== undefined);
+    return entries.length ? Object.fromEntries(entries) : undefined;
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}