@memorax/memorax-code 0.1.0

package/lib/memorax-code-backend/dist/client-plugin-removal.js

@@ -0,0 +1,67 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { cleanupCodexAfterBackendRemoval, } from "./codex-plugin-install.js";
+export async function prepareClientPluginRemovalCleanup(options = {}) {
+    const claudePluginInstaller = await loadClaudePluginInstaller();
+    const home = resolveHome(options.homeDir);
+    const memoraxCodeHome = resolve(options.memoraxCodeHome ?? process.env.MEMORAX_CODE_HOME ?? join(home, ".memorax-code"));
+    const claudeState = await readJsonRecord(join(memoraxCodeHome, "adapters", "claude-code", "state.json"));
+    const claudeHome = options.claudeHome ?? stringField(claudeState, "claudeHome");
+    return async () => {
+        const [codexPlugin, claudePlugin] = await Promise.all([
+            cleanupCodexAfterBackendRemoval({
+                memoraxCodeHome,
+                homeDir: home,
+                codexHome: options.codexHome,
+                codexCommand: options.codexCommand,
+            }).catch((error) => removalFailure("backend-removal-cleanup", error)),
+            Promise.resolve()
+                .then(() => claudePluginInstaller.removeClaudePluginInstallation({
+                memoraxCodeHome,
+                ...(claudeHome ? { claudeHome } : {}),
+                ...(options.claudeCommand ? { claudeCommand: options.claudeCommand } : {}),
+            }))
+                .catch((error) => removalFailure("claude-plugin-remove", error)),
+        ]);
+        return {
+            ok: codexPlugin.ok && claudePlugin.ok,
+            action: "client-plugin-removal-cleanup",
+            codexPlugin,
+            claudePlugin,
+        };
+    };
+}
+async function loadClaudePluginInstaller() {
+    return await import(new URL("../../memorax-code-claude-adapter/src/plugin-install.mjs", import.meta.url).href);
+}
+async function readJsonRecord(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const parsed = JSON.parse(await readFile(path, "utf8"));
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function stringField(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" && value.trim() ? value : undefined;
+}
+function resolveHome(value) {
+    return resolve(value ?? process.env.HOME ?? homedir());
+}
+function removalFailure(action, error) {
+    return {
+        ok: false,
+        action,
+        reason: "plugin_remove_failed",
+        message: error instanceof Error ? error.message : String(error),
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/lib/memorax-code-backend/dist/client-selection.js

@@ -0,0 +1,36 @@
+import { loadLifecycleMemoraxCodeConfig } from "./memorax-code-config.js";
+const allClients = Object.freeze({ codex: true, claude: true });
+export function resolveManagedClients(argv, config = {}) {
+    const explicit = argValue(argv, "--clients");
+    if (explicit !== undefined)
+        return parseManagedClients(explicit);
+    if (config.clients !== undefined) {
+        return {
+            codex: config.clients.codex === true,
+            claude: config.clients.claude === true,
+        };
+    }
+    return allClients;
+}
+export function parseManagedClients(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "all")
+        return allClients;
+    if (normalized === "none")
+        return { codex: false, claude: false };
+    const names = normalized.split(",").map((name) => name.trim()).filter(Boolean);
+    if (names.length === 0 || names.some((name) => name !== "codex" && name !== "claude")) {
+        throw new Error(`invalid --clients value: ${value}; expected codex, claude, codex,claude, all, or none`);
+    }
+    return {
+        codex: names.includes("codex"),
+        claude: names.includes("claude"),
+    };
+}
+export function loadManagedClientsConfig(memoraxCodeHome) {
+    return loadLifecycleMemoraxCodeConfig(memoraxCodeHome);
+}
+function argValue(argv, name) {
+    const index = argv.indexOf(name);
+    return index >= 0 ? argv[index + 1] ?? "" : undefined;
+}

package/lib/memorax-code-backend/dist/codex-adapter-lifecycle.js

@@ -0,0 +1,131 @@
+import { createInterface } from "node:readline/promises";
+import { installCodexPlugin, isCodexPluginActive, isCodexPluginStaged, removeCodexPlugin, } from "./codex-plugin-install.js";
+const BACKEND_PREFIX = "[MemoraX Code Backend]:";
+const GREEN = "\x1b[32m";
+const RESET = "\x1b[0m";
+export async function enableCodexAdapterForStart(argv, serviceOptions, backendUrl) {
+    try {
+        let options = codexAdapterOptions(argv, serviceOptions, backendUrl);
+        const codexHome = typeof options.codexHome === "string" ? options.codexHome : undefined;
+        if (!isCodexPluginActive({ codexHome }) && !isCodexPluginStaged({ codexHome })) {
+            const installed = await maybeInstallCodexPluginForStart(argv);
+            if (installed) {
+                backendLog(green("Codex plugin source registered. Activate the MemoraX Code Codex Adapter plugin, then restart or refresh Codex."));
+            }
+            else if (installed === false) {
+                return codexPluginNotInstalled();
+            }
+        }
+        options = codexAdapterOptions(argv, serviceOptions, backendUrl);
+        if (!isCodexPluginActive({ codexHome })) {
+            return isCodexPluginStaged({ codexHome })
+                ? codexPluginActivationRequired()
+                : codexPluginNotInstalled();
+        }
+        return (await loadCodexAdapterConfig()).enableCodexAdapter(options);
+    }
+    catch (error) {
+        return { ok: false, action: "enable", error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export async function readCodexAdapterStatusForLifecycle(argv, serviceOptions, backendUrl) {
+    try {
+        return (await loadCodexAdapterConfig()).readCodexAdapterStatus(codexAdapterOptions(argv, serviceOptions, backendUrl));
+    }
+    catch (error) {
+        return { ok: false, action: "status", error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export async function disableCodexAdapterForLifecycle(argv, serviceOptions) {
+    try {
+        return (await loadCodexAdapterConfig()).disableCodexAdapter(codexAdapterOptions(argv, serviceOptions));
+    }
+    catch (error) {
+        return { ok: false, action: "disable", error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export const codexAdapterLifecycle = {
+    status: ({ argv, serviceOptions, backendUrl }) => (readCodexAdapterStatusForLifecycle(argv, serviceOptions, backendUrl)),
+    prepareEnable: ({ argv, serviceOptions, backendUrl }) => (enableCodexAdapterForStart(argv, serviceOptions, backendUrl)),
+    disable: ({ argv, serviceOptions }) => (disableCodexAdapterForLifecycle(argv, serviceOptions)),
+    remove: ({ argv }) => removeCodexPlugin(codexPluginRemoveOptions(argv)),
+};
+function codexAdapterOptions(argv, serviceOptions, backendUrl) {
+    const codexHome = argValue(argv, "--codex-home");
+    return {
+        ...(codexHome ? { codexHome } : {}),
+        memoraxCodeHome: serviceOptions.home,
+        ...(backendUrl ? { backendUrl } : {}),
+    };
+}
+function codexPluginNotInstalled() {
+    return {
+        ok: true,
+        action: "enable",
+        skipped: true,
+        reason: "codex_plugin_not_installed",
+        message: "Codex plugin is not installed; run `memorax-code codex-plugin install`, then activate it and rerun `memorax-code start`.",
+    };
+}
+function codexPluginActivationRequired() {
+    return {
+        ok: true,
+        action: "enable",
+        skipped: true,
+        reason: "codex_plugin_activation_required",
+        message: "Codex plugin source is registered but not active; run `memorax-code codex-plugin activate --yes`, then rerun `memorax-code start`.",
+    };
+}
+async function maybeInstallCodexPluginForStart(argv) {
+    if (argv.includes("--json"))
+        return undefined;
+    if (argv.includes("--yes")) {
+        await installCodexPlugin(codexPluginInstallOptions(argv));
+        return true;
+    }
+    if (!canPromptOnStdin())
+        return undefined;
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question(`${BACKEND_PREFIX} Install MemoraX Code Codex Adapter plugin now? [y/N] `);
+        if (!process.stdout.isTTY)
+            process.stdout.write("\n");
+        if (!/^y(?:es)?$/i.test(answer.trim()))
+            return false;
+        await installCodexPlugin(codexPluginInstallOptions(argv));
+        return true;
+    }
+    finally {
+        rl.close();
+    }
+}
+function codexPluginInstallOptions(argv) {
+    return {
+        codexHome: argValue(argv, "--codex-home"),
+        marketplacePath: argValue(argv, "--marketplace-path"),
+        pluginSourcePath: argValue(argv, "--plugin-source-path"),
+        codexCommand: argValue(argv, "--codex-command"),
+    };
+}
+function codexPluginRemoveOptions(argv) {
+    return {
+        ...codexPluginInstallOptions(argv),
+        workspace: argValue(argv, "--workspace"),
+    };
+}
+function canPromptOnStdin() {
+    return process.stdin.isTTY === true;
+}
+function backendLog(message) {
+    console.log(`${BACKEND_PREFIX} ${message}`);
+}
+function green(value) {
+    return `${GREEN}${value}${RESET}`;
+}
+function argValue(argv, name) {
+    const index = argv.indexOf(name);
+    return index >= 0 ? argv[index + 1] : undefined;
+}
+async function loadCodexAdapterConfig() {
+    return await import(new URL("../../memorax-code-codex-adapter/src/config.mjs", import.meta.url).href);
+}

package/lib/memorax-code-backend/dist/codex-effective-prompt.js

@@ -0,0 +1,54 @@
+export function stripCodexPreambleSegments(text) {
+    let remaining = text;
+    for (;;) {
+        const next = stripOneLeadingCodexPreambleSegment(remaining);
+        if (next === remaining) {
+            return stripCodexSkillSegments(stripCodexAmbientUiSegments(remaining)).trim();
+        }
+        remaining = next.trimStart();
+    }
+}
+function stripOneLeadingCodexPreambleSegment(text) {
+    return stripLeadingEnvironmentContext(text)
+        ?? stripLeadingInstructionsBlock(text)
+        ?? stripLeadingSessionPreamble(text)
+        ?? text;
+}
+function stripCodexSkillSegments(text) {
+    return text.replace(/(^|\n)[^\S\n]*<skill\b[\s\S]*?<\/skill>[^\S\n]*(?=\n|$)/gi, (match, prefix) => {
+        const block = match.slice(prefix.length).trim();
+        return isCodexSkillSegment(block) ? prefix : match;
+    });
+}
+function stripCodexAmbientUiSegments(text) {
+    let removedAmbientContext = false;
+    const withoutAmbientContext = text.replace(/(^|\n)[^\S\n]*<in-app-browser-context\b[\s\S]*?<\/in-app-browser-context>[^\S\n]*(?=\n|$)/gi, (_match, prefix) => {
+        removedAmbientContext = true;
+        return prefix;
+    });
+    if (!removedAmbientContext)
+        return text;
+    return withoutAmbientContext
+        .replace(/(^|\n)[^\S\n]*##\s+My request for Codex:[^\S\n]*(?=\n|$)/gi, "$1")
+        .replace(/\n[^\S\n]*(?:\n[^\S\n]*){2,}/g, "\n\n");
+}
+function isCodexSkillSegment(text) {
+    return /^<skill\b/i.test(text)
+        && /<name>[^<\n]+<\/name>/i.test(text)
+        && /<path>[\s\S]*?SKILL\.md[\s\S]*?<\/path>/i.test(text);
+}
+function stripLeadingEnvironmentContext(text) {
+    const match = text.match(/^\s*<environment_context\b[\s\S]*?<\/environment_context>\s*/);
+    return match ? text.slice(match[0].length) : undefined;
+}
+function stripLeadingInstructionsBlock(text) {
+    const match = text.match(/^\s*#\s+(?:AGENTS|CLAUDE)\.md[^\n]*[\s\S]*?<\/INSTRUCTIONS>\s*/i);
+    return match ? text.slice(match[0].length) : undefined;
+}
+function stripLeadingSessionPreamble(text) {
+    const trimmed = text.trimStart();
+    if (!trimmed.startsWith("You are Claude Code"))
+        return undefined;
+    const boundary = trimmed.indexOf("\n\n");
+    return boundary >= 0 ? trimmed.slice(boundary + 2) : "";
+}