@memorax/memorax-code 0.1.0

package/lib/memorax-code-adapter-common/src/hooks/memory-skill-reminder-hook.mjs

@@ -0,0 +1,277 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  atomicWriteJson,
+  readJsonFile,
+  readStdinJson,
+  stringOption,
+  withJsonFileLock,
+} from "../config-utils.mjs";
+
+const DEFAULT_REMINDER_INTERVAL_TURNS = 5;
+const DEFAULT_MEMORY_SKILL_INVOCATION = "$memorax-code";
+export const PERSONAL_MEMORY_REMINDER_CONTEXT = personalMemoryReminderContext();
+
+export function personalMemoryReminderContext(memorySkillInvocation) {
+  const invocation = stringOption(memorySkillInvocation) ?? DEFAULT_MEMORY_SKILL_INVOCATION;
+  return [
+    `MemoraX Code personal-memory reminder: Use ${invocation} when the user states a durable current-repo identity or interaction preference, asks to list or recall stored personal memory, or explicitly asks to save, update, forget, or delete it.`,
+    "Route reusable action sequences and work rules to procedure memory; do not store repository facts, one-off task details, or secrets.",
+  ].join(" ");
+}
+
+export async function runMemorySkillReminderHook(options, hookInput) {
+  try {
+    const input = hookInput ?? await readStdinJson();
+    const sessionId = stringOption(input.session_id) ?? stringOption(input.sessionId);
+    if (!sessionId) return;
+    const transcriptPath = stringOption(input.transcript_path) ?? stringOption(input.transcriptPath);
+    if (options.requireTranscriptPath && !transcriptPath) return;
+    const hookEventName = stringOption(input.hook_event_name) ?? stringOption(input.hookEventName) ?? "UserPromptSubmit";
+
+    const memoraxCodeHome = process.env.MEMORAX_CODE_HOME || defaultMemoraxCodeHome();
+    if (hookEventName !== "UserPromptSubmit") return;
+
+    const statePath = join(memoraxCodeHome, "adapters", options.adapterDir, "memory-skill-reminders.json");
+    const turnId = stringOption(input.turn_id)
+      ?? stringOption(input.turnId)
+      ?? stringOption(input.prompt_id)
+      ?? stringOption(input.promptId);
+    const intervalTurns = reminderIntervalTurns(memoraxCodeHome);
+    const update = withJsonFileLock(statePath, () => {
+      const existing = readJsonFile(statePath);
+      const next = nextReminderState(
+        existing?.unreadable ? undefined : existing?.value,
+        options.runtime,
+        sessionId,
+        turnId,
+      );
+      if (next.duplicate) return next;
+      const sessionState = next.state.sessions[sessionId];
+      const memoryReminderDue = shouldRemind(
+        sessionState?.turnCount,
+        intervalTurns,
+        options.remindOnFirstTurn !== false,
+      );
+      const supplementalReminderDue = options.supplementalReminderAfterCompact === true
+        && sessionState?.supplementalReminderPending === true;
+      if (supplementalReminderDue) sessionState.supplementalReminderPending = false;
+      atomicWriteJson(statePath, next.state);
+      return {
+        ...next,
+        memoryReminderDue,
+        supplementalReminderDue,
+        turnCount: sessionState?.turnCount,
+      };
+    });
+    if (update.duplicate) return;
+    const { memoryReminderDue, supplementalReminderDue } = update;
+
+    const baseAdditionalContext = stringOption(options.baseAdditionalContext);
+    if (baseAdditionalContext || memoryReminderDue || supplementalReminderDue) {
+      const cadenceReminderContext = memoryReminderDue
+        ? await buildCadenceReminderContext(options, input)
+        : undefined;
+      const personalMemoryContext = supplementalReminderDue || (memoryReminderDue && update.turnCount === 1)
+        ? await buildPersonalMemoryContext(options, input)
+        : undefined;
+      const reminderContext = stringOption(combinedReminderContext(options, {
+        memoryReminderDue,
+        supplementalReminderDue,
+      }, cadenceReminderContext, personalMemoryContext));
+      const additionalContext = [baseAdditionalContext, reminderContext].filter(Boolean).join("\n\n");
+      const triggers = [
+        ...(memoryReminderDue ? ["cadence"] : []),
+        ...(supplementalReminderDue ? ["post_compaction"] : []),
+      ];
+      process.stdout.write(`${JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "UserPromptSubmit",
+          additionalContext,
+        },
+      })}\n`);
+      if (reminderContext) {
+        await notifyReminder(options, {
+          sessionId,
+          turnId,
+          transcriptPath,
+          cwd: stringOption(input.cwd),
+          workspaceKind: stringOption(input.workspace_kind) ?? stringOption(input.workspaceKind),
+          content: reminderContext,
+          triggers,
+        });
+      }
+    }
+  } catch (error) {
+    if (process.env[options.debugEnv] === "1") {
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+  }
+}
+
+async function notifyReminder(options, reminder) {
+  if (typeof options.onReminder !== "function") return;
+  try {
+    await options.onReminder(reminder);
+  } catch (error) {
+    if (process.env[options.debugEnv] === "1") {
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+  }
+}
+
+export function markSupplementalReminderAfterCompact(options, input) {
+  try {
+    const hookEventName = stringOption(input.hook_event_name) ?? stringOption(input.hookEventName);
+    if (hookEventName !== "SessionStart" || stringOption(input.source) !== "compact") return;
+    const sessionId = stringOption(input.session_id) ?? stringOption(input.sessionId);
+    if (!sessionId) return;
+    const memoraxCodeHome = process.env.MEMORAX_CODE_HOME || defaultMemoraxCodeHome();
+    const statePath = join(memoraxCodeHome, "adapters", options.adapterDir, "memory-skill-reminders.json");
+    withJsonFileLock(statePath, () => {
+      const existing = readJsonFile(statePath);
+      atomicWriteJson(statePath, markSupplementalReminderPending(
+        existing?.unreadable ? undefined : existing?.value,
+        options.runtime,
+        sessionId,
+      ));
+    });
+  } catch (error) {
+    if (process.env[options.debugEnv] === "1") {
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+  }
+}
+
+async function buildCadenceReminderContext(options, input) {
+  if (typeof options.buildCadenceReminderContext !== "function") return undefined;
+  try {
+    return stringOption(await options.buildCadenceReminderContext(input));
+  } catch (error) {
+    if (process.env[options.debugEnv] === "1") {
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+    return undefined;
+  }
+}
+
+async function buildPersonalMemoryContext(options, input) {
+  if (typeof options.buildPersonalMemoryContext !== "function") return undefined;
+  try {
+    return stringOption(await options.buildPersonalMemoryContext(input));
+  } catch (error) {
+    if (process.env[options.debugEnv] === "1") {
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+    return undefined;
+  }
+}
+
+function combinedReminderContext(options, due, cadenceReminderContext, personalMemoryContext) {
+  const contexts = [];
+  if (due.memoryReminderDue) contexts.push(memoryReminderContext(options));
+  if (due.supplementalReminderDue || personalMemoryContext) {
+    const additionalReminderContext = stringOption(options.additionalReminderContext);
+    if (additionalReminderContext) contexts.push(additionalReminderContext);
+  }
+  if (personalMemoryContext) contexts.push(personalMemoryContext);
+  if (due.memoryReminderDue && cadenceReminderContext) contexts.push(cadenceReminderContext);
+
+  return contexts.join("\n\n");
+}
+
+function memoryReminderContext(options) {
+  const invocation = stringOption(options.memorySkillInvocation) ?? DEFAULT_MEMORY_SKILL_INVOCATION;
+  return `MemoraX Code reminder: proactively invoke ${invocation} whenever coding memory might help, even when uncertain; when in doubt, run one focused coding-memory search for relevant prior knowledge. Also use ${invocation} for repository-scoped personal memory, and classify the authority before reading or writing.`;
+}
+
+function defaultMemoraxCodeHome() {
+  return process.env.HOME ? join(process.env.HOME, ".memorax-code") : ".memorax-code";
+}
+
+function nextReminderState(existing, runtime, sessionId, turnId) {
+  const state = reminderState(existing, runtime);
+  const current = state.sessions[sessionId] && typeof state.sessions[sessionId] === "object" && !Array.isArray(state.sessions[sessionId])
+    ? state.sessions[sessionId]
+    : {};
+  if (turnId && current.lastTurnId === turnId) return { state, duplicate: true };
+  const currentCount = Number.isInteger(current.turnCount) && current.turnCount >= 0 ? current.turnCount : 0;
+  state.sessions[sessionId] = {
+    ...current,
+    turnCount: currentCount + 1,
+    ...(turnId ? { lastTurnId: turnId } : {}),
+    lastSeenAt: state.updatedAt,
+  };
+  return { state, duplicate: false };
+}
+
+function markSupplementalReminderPending(existing, runtime, sessionId) {
+  const state = reminderState(existing, runtime);
+  const current = state.sessions[sessionId] && typeof state.sessions[sessionId] === "object" && !Array.isArray(state.sessions[sessionId])
+    ? state.sessions[sessionId]
+    : {};
+  state.sessions[sessionId] = {
+    ...current,
+    supplementalReminderPending: true,
+    lastSeenAt: state.updatedAt,
+  };
+  return state;
+}
+
+function reminderState(existing, runtime) {
+  const state = existing && typeof existing === "object" && !Array.isArray(existing)
+    ? existing
+    : { version: 1, runtime, sessions: {} };
+  state.version = 1;
+  state.runtime = runtime;
+  state.updatedAt = new Date().toISOString();
+  state.sessions = state.sessions && typeof state.sessions === "object" && !Array.isArray(state.sessions)
+    ? state.sessions
+    : {};
+  return state;
+}
+
+function shouldRemind(turnCount, intervalTurns, remindOnFirstTurn) {
+  if (!Number.isInteger(turnCount) || turnCount <= 0) return false;
+  if (remindOnFirstTurn) return (turnCount - 1) % intervalTurns === 0;
+  return turnCount > intervalTurns && (turnCount - 1) % intervalTurns === 0;
+}
+
+function reminderIntervalTurns(memoraxCodeHome) {
+  return positiveInteger(process.env.MEMORAX_CODE_MEMORY_SKILL_REMINDER_INTERVAL_TURNS)
+    ?? configReminderIntervalTurns(join(memoraxCodeHome, "config.toml"))
+    ?? DEFAULT_REMINDER_INTERVAL_TURNS;
+}
+
+function configReminderIntervalTurns(path) {
+  try {
+    return parseReminderIntervalTurns(readFileSync(path, "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+function parseReminderIntervalTurns(text) {
+  let section = "";
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.split("#", 1)[0].trim();
+    if (!line) continue;
+    const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+    if (sectionMatch) {
+      section = sectionMatch[1].trim();
+      continue;
+    }
+    if (section !== "memory.skill_reminder") continue;
+    const fieldMatch = line.match(/^interval_turns\s*=\s*(.+)$/);
+    if (fieldMatch) return positiveInteger(fieldMatch[1]);
+  }
+  return undefined;
+}
+
+function positiveInteger(value) {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.trim().replaceAll("_", "");
+  if (!/^[1-9]\d*$/.test(normalized)) return undefined;
+  const parsed = Number(normalized);
+  return Number.isSafeInteger(parsed) ? parsed : undefined;
+}

package/lib/memorax-code-adapter-common/src/memorax-code-config-file.d.mts

@@ -0,0 +1,28 @@
+export const CONFIG_UPDATE_WARNING: string;
+
+export type ConfigFileUpdateResult = "created" | "updated" | "unchanged" | "failed";
+
+export function updateConfigFileAtomically(options: {
+  path: string;
+  defaultText: string;
+  transform: (text: string, parsed: unknown) => string;
+  parseToml: (text: string) => unknown;
+  warn?: (message: string) => void;
+  operations?: Record<string, (...args: any[]) => any>;
+  platform?: NodeJS.Platform;
+}): ConfigFileUpdateResult;
+
+export function ensurePrivateConfigDirectory(
+  path: string,
+  options?: {
+    operations?: Record<string, (...args: any[]) => any>;
+    platform?: NodeJS.Platform;
+  },
+): void;
+
+export function setTomlField(
+  text: string,
+  section: string,
+  key: string,
+  renderedValue: string | undefined,
+): string;

package/lib/memorax-code-adapter-common/src/memorax-code-config-file.mjs

@@ -0,0 +1,296 @@
+import {
+  accessSync,
+  chmodSync,
+  closeSync,
+  constants,
+  copyFileSync,
+  fchmodSync,
+  fchownSync,
+  linkSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { randomUUID } from "node:crypto";
+import { basename, dirname, join } from "node:path";
+
+export const CONFIG_UPDATE_WARNING = "MemoraX Code config could not be safely updated or verified; existing config was preserved.";
+
+const defaultOperations = {
+  accessSync,
+  chmodSync,
+  closeSync,
+  copyFileSync,
+  fchmodSync,
+  fchownSync,
+  linkSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+};
+
+export function updateConfigFileAtomically({
+  path,
+  defaultText,
+  transform,
+  parseToml,
+  warn = console.warn,
+  operations = {},
+  platform = process.platform,
+}) {
+  const fs = { ...defaultOperations, ...operations };
+  let existingStat;
+  try {
+    existingStat = fs.lstatSync(path);
+    if (!existingStat.isFile()) return failed(warn);
+  } catch (error) {
+    if (!isNodeError(error) || error.code !== "ENOENT") return failed(warn);
+  }
+
+  let existingText;
+  if (existingStat) {
+    try {
+      existingText = fs.readFileSync(path, "utf8");
+    } catch {
+      return failed(warn);
+    }
+  }
+
+  let candidate;
+  let unchanged = false;
+  try {
+    if (existingText === undefined) {
+      candidate = defaultText;
+    } else {
+      const parsed = parseToml(existingText);
+      candidate = transform(existingText, parsed);
+      unchanged = candidate === existingText;
+    }
+    if (!unchanged) parseToml(candidate);
+  } catch {
+    return failed(warn);
+  }
+
+  try {
+    ensurePrivateConfigDirectoryWithOperations(fs, path, platform);
+  } catch {
+    return failed(warn);
+  }
+  if (unchanged) return "unchanged";
+  if (existingText !== undefined) {
+    try {
+      fs.accessSync(path, constants.W_OK);
+    } catch {
+      return failed(warn);
+    }
+  }
+
+  const uniqueSuffix = `${process.pid}.${randomUUID()}`;
+  const tempPath = join(dirname(path), `.${basename(path)}.${uniqueSuffix}.tmp`);
+  const backupPath = existingStat
+    ? join(dirname(path), `.${basename(path)}.${uniqueSuffix}.bak`)
+    : undefined;
+  let fd;
+  let backupCreated = false;
+  let renamed = false;
+  try {
+    fd = fs.openSync(tempPath, "wx", 0o600);
+    fs.writeFileSync(fd, candidate, "utf8");
+    if (existingStat && platform !== "win32") {
+      fs.fchownSync(fd, existingStat.uid, existingStat.gid);
+      fs.fchmodSync(fd, existingStat.mode & 0o7777);
+    } else if (!existingStat && platform !== "win32") {
+      fs.fchmodSync(fd, 0o600);
+    }
+    fs.closeSync(fd);
+    fd = undefined;
+    if (backupPath) {
+      if (platform === "win32") {
+        fs.copyFileSync(path, backupPath, constants.COPYFILE_EXCL);
+      } else {
+        fs.linkSync(path, backupPath);
+      }
+      backupCreated = true;
+    }
+    fs.renameSync(tempPath, path);
+    renamed = true;
+  } catch {
+    if (fd !== undefined) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+        // Best effort: unlinking an open temporary file is safe on supported Unix hosts.
+      }
+    }
+    if (!renamed) {
+      try {
+        fs.unlinkSync(tempPath);
+      } catch {
+        // The temporary file may not have been created or may already have been renamed.
+      }
+    }
+    if (backupCreated && backupPath) {
+      try {
+        fs.unlinkSync(backupPath);
+      } catch {
+        // The original target is still authoritative when rename has not completed.
+      }
+    }
+    return failed(warn);
+  }
+
+  try {
+    const verifiedText = fs.readFileSync(path, "utf8");
+    if (verifiedText !== candidate) throw new Error("config verification failed");
+    parseToml(verifiedText);
+    const verifiedStat = fs.lstatSync(path);
+    if (!verifiedStat.isFile()) throw new Error("config type verification failed");
+    if (platform !== "win32") {
+      const expectedMode = existingStat ? existingStat.mode & 0o7777 : 0o600;
+      if ((verifiedStat.mode & 0o7777) !== expectedMode) throw new Error("config mode verification failed");
+      if (existingStat && (verifiedStat.uid !== existingStat.uid || verifiedStat.gid !== existingStat.gid)) {
+        throw new Error("config owner verification failed");
+      }
+    }
+    if (backupCreated && backupPath) {
+      fs.unlinkSync(backupPath);
+      backupCreated = false;
+    }
+  } catch {
+    if (existingStat && backupCreated && backupPath) {
+      if (platform === "win32") {
+        const restorePath = join(dirname(path), `.${basename(path)}.${uniqueSuffix}.restore.tmp`);
+        let restoreCopied = false;
+        try {
+          fs.copyFileSync(backupPath, restorePath, constants.COPYFILE_EXCL);
+          restoreCopied = true;
+          fs.renameSync(restorePath, path);
+          restoreCopied = false;
+          fs.unlinkSync(backupPath);
+          backupCreated = false;
+        } catch {
+          if (restoreCopied) {
+            try {
+              fs.unlinkSync(restorePath);
+            } catch {
+              // Keep the original backup for operator recovery.
+            }
+          }
+        }
+      } else {
+        try {
+          fs.renameSync(backupPath, path);
+          backupCreated = false;
+        } catch {
+          // Keep the hard-link backup for operator recovery if atomic restore itself fails.
+        }
+      }
+    } else if (!existingStat) {
+      try {
+        fs.unlinkSync(path);
+      } catch {
+        // Best effort: the new target may already be absent.
+      }
+    }
+    return failed(warn);
+  }
+  return existingText === undefined ? "created" : "updated";
+}
+
+export function ensurePrivateConfigDirectory(
+  path,
+  { operations = {}, platform = process.platform } = {},
+) {
+  const fs = { ...defaultOperations, ...operations };
+  ensurePrivateConfigDirectoryWithOperations(fs, path, platform);
+}
+
+export function setTomlField(text, section, key, renderedValue) {
+  const source = String(text ?? "");
+  const newline = source.includes("\r\n") ? "\r\n" : "\n";
+  const lines = source.split(/\r?\n/);
+  const escapedSection = section.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const header = new RegExp(`^\\s*\\[(?:${escapedSection}|"${escapedSection}"|'${escapedSection}')\\]\\s*(?:#.*)?$`);
+  const assignment = new RegExp(`^(\\s*(?:${escapedKey}|"${escapedKey}"|'${escapedKey}')\\s*=\\s*)`);
+  const start = lines.findIndex((line) => header.test(line));
+  if (start === -1) {
+    if (renderedValue === undefined) return source;
+    const separator = source.length === 0
+      ? ""
+      : source.endsWith(`${newline}${newline}`)
+        ? ""
+        : source.endsWith(newline)
+          ? newline
+          : `${newline}${newline}`;
+    return `${source}${separator}[${section}]${newline}${key} = ${renderedValue}${newline}`;
+  }
+  const nextHeader = lines.findIndex((line, index) => index > start && /^\s*\[/.test(line));
+  const end = nextHeader === -1 ? lines.length : nextHeader;
+  const field = lines.findIndex((line, index) => index > start && index < end && assignment.test(line));
+  if (field !== -1) {
+    if (renderedValue === undefined) {
+      lines.splice(field, 1);
+    } else {
+      const prefix = lines[field].match(assignment)?.[1] ?? `${key} = `;
+      const comment = tomlInlineComment(lines[field].slice(prefix.length));
+      lines[field] = `${prefix}${renderedValue}${comment}`;
+    }
+  } else if (renderedValue !== undefined) {
+    lines.splice(start + 1, 0, `${key} = ${renderedValue}`);
+  }
+  return lines.join(newline);
+}
+
+function ensurePrivateConfigDirectoryWithOperations(fs, path, platform) {
+  const directoryPath = dirname(path);
+  fs.mkdirSync(directoryPath, { recursive: true, mode: 0o700 });
+  if (platform !== "win32") fs.chmodSync(directoryPath, 0o700);
+}
+
+function failed(warn) {
+  warn(CONFIG_UPDATE_WARNING);
+  return "failed";
+}
+
+function tomlInlineComment(value) {
+  let quote;
+  let escaped = false;
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index];
+    if (quote === '"' && escaped) {
+      escaped = false;
+      continue;
+    }
+    if (quote === '"' && character === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (character === quote) quote = undefined;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === "#") {
+      let commentStart = index;
+      while (commentStart > 0 && /[ \t]/.test(value[commentStart - 1])) commentStart -= 1;
+      return value.slice(commentStart);
+    }
+  }
+  return "";
+}
+
+function isNodeError(error) {
+  return error instanceof Error;
+}

package/lib/memorax-code-adapter-common/src/memorax-defaults.d.mts

@@ -0,0 +1,10 @@
+export const MEMORAX_DEFAULT_BASE_URL: "https://platform.memorax.net";
+export const MEMORAX_ACCOUNT_URL: "https://platform.memorax.net/";
+export const MEMORAX_DEFAULT_MEMORY_OUTPUT_LANGUAGE: "zh";
+
+export type MemoraxMemoryOutputLanguage = "zh" | "en";
+
+export function normalizeMemoraxBaseUrl(value: unknown): string;
+export function normalizeMemoraxMemoryOutputLanguage(
+  value: unknown,
+): MemoraxMemoryOutputLanguage | undefined;

package/lib/memorax-code-adapter-common/src/memorax-defaults.mjs

@@ -0,0 +1,12 @@
+export const MEMORAX_DEFAULT_BASE_URL = "https://platform.memorax.net";
+export const MEMORAX_ACCOUNT_URL = "https://platform.memorax.net/";
+export const MEMORAX_DEFAULT_MEMORY_OUTPUT_LANGUAGE = "zh";
+
+export function normalizeMemoraxBaseUrl(value) {
+  return String(value ?? "").trim().replace(/\/+$/, "");
+}
+
+export function normalizeMemoraxMemoryOutputLanguage(value) {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  return normalized === "zh" || normalized === "en" ? normalized : undefined;
+}

package/lib/memorax-code-adapter-common/src/repo-memory/repo-memory-job-context.mjs

@@ -0,0 +1,28 @@
+const INTERNAL_JOB_KIND = "repo-memory";
+const JOB_ID_PATTERN = /^\d{17}-(?:build|update)-[a-zA-Z0-9_.-]+-[0-9a-f]{8}$/;
+const RUN_ID_PATTERN = /^[0-9a-f]{32}$/;
+
+export function readRepoMemoryJobWorkerContext(env = process.env) {
+  if (env.MEMORAX_CODE_REPO_MEMORY_JOB_KIND !== INTERNAL_JOB_KIND) return undefined;
+  const jobId = stringValue(env.MEMORAX_CODE_REPO_MEMORY_JOB_ID);
+  const runId = stringValue(env.MEMORAX_CODE_REPO_MEMORY_JOB_RUN_ID);
+  if (!jobId || !JOB_ID_PATTERN.test(jobId) || !runId || !RUN_ID_PATTERN.test(runId)) return undefined;
+  return { kind: INTERNAL_JOB_KIND, jobId, runId };
+}
+
+export function isRepoMemoryJobWorker(env = process.env) {
+  return readRepoMemoryJobWorkerContext(env) !== undefined;
+}
+
+export function repoMemoryJobWorkerEnv(input, env = process.env) {
+  return {
+    ...env,
+    MEMORAX_CODE_REPO_MEMORY_JOB_KIND: INTERNAL_JOB_KIND,
+    MEMORAX_CODE_REPO_MEMORY_JOB_ID: input.jobId,
+    MEMORAX_CODE_REPO_MEMORY_JOB_RUN_ID: input.runId,
+  };
+}
+
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}