@memorax/memorax-code 0.1.0

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

@@ -0,0 +1,411 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { atomicWriteJson, readJsonFile, stringOption } from "../config-utils.mjs";
+import {
+  readActiveRepoMemoryJobMarker,
+  realpathRepo,
+  removeRepoMemoryJobMarkerIfOwned,
+} from "./repo-memory-job-marker.mjs";
+import {
+  readRepoMemoryJobWorkerContext,
+  repoMemoryJobWorkerEnv,
+} from "./repo-memory-job-context.mjs";
+import { resolveWindowsCliInvocation } from "../windows-cli-invocation.mjs";
+
+let activeChild;
+let activeRequest;
+let activeWorkerContext;
+let requestedSignal;
+
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.on(signal, () => {
+    requestedSignal = signal;
+    activeChild?.kill(signal);
+  });
+}
+
+try {
+  const succeeded = await main(process.argv.slice(2));
+  process.exitCode = succeeded ? 0 : 1;
+} catch (error) {
+  if (!recordUnhandledFailure(error)) {
+    process.stderr.write(`repo memory worker failed: ${errorMessage(error)}\n`);
+  }
+  process.exitCode = 1;
+}
+
+async function main(args) {
+  const request = parseArgs(args);
+  const workerContext = readRepoMemoryJobWorkerContext();
+  if (!workerContext) throw new Error("missing trusted repo memory worker context");
+  const repo = realpathRepo(resolve(request.repo));
+  activeRequest = { ...request, repo };
+  activeWorkerContext = workerContext;
+  await waitForOwnedMarker({
+    memoraxCodeHome: request.memoraxCodeHome,
+    repo,
+    jobId: workerContext.jobId,
+    runId: workerContext.runId,
+  });
+
+  const initial = readJobState(request.jobPath);
+  assertJobIdentity(initial, {
+    repo,
+    jobId: workerContext.jobId,
+    runId: workerContext.runId,
+  });
+  if (initial.status !== "started") throw new Error(`repo memory job cannot start from status ${initial.status}`);
+  let state = writeJobState(request.jobPath, {
+    ...initial,
+    status: "running",
+    pid: process.pid,
+    workerPid: process.pid,
+    workerStartedAt: new Date().toISOString(),
+  });
+
+  if (requestedSignal) {
+    return finishFailed(request, state, workerContext, "worker_interrupted", { signal: requestedSignal });
+  }
+
+  const runner = runnerName(state.runner);
+  const command = normalizedCommand(state.command);
+  const childResult = await runClient(command, {
+    captureStdout: finalMessageSource(state.finalMessageSource) === "stdout",
+    cwd: repo,
+    env: {
+      ...repoMemoryJobWorkerEnv(workerContext),
+      MEMORAX_CODE_REPO_MEMORY_SNAPSHOT_HEAD: state.snapshotHead,
+      MEMORAX_CODE_REPO_MEMORY_JOB_MODE: state.mode,
+    },
+    onSpawn(childPid) {
+      state = writeJobState(request.jobPath, {
+        ...state,
+        childPid,
+      });
+    },
+    finalMessagePath: state.finalMessagePath,
+  });
+  state = readJobState(request.jobPath);
+
+  if (childResult.error) {
+    return finishFailed(request, state, workerContext, `${runner}_spawn_failed`, {
+      error: childResult.error.message,
+    });
+  }
+  if (childResult.code !== 0) {
+    return finishFailed(request, state, workerContext, requestedSignal ? "worker_interrupted" : `${runner}_exit_nonzero`, {
+      exitCode: childResult.code,
+      signal: childResult.signal,
+    });
+  }
+  if (!nonEmptyFile(state.finalMessagePath)) {
+    return finishFailed(request, state, workerContext, "final_message_missing", {
+      exitCode: childResult.code,
+      signal: childResult.signal,
+    });
+  }
+
+  const currentHead = gitHead(repo);
+  if (currentHead !== state.snapshotHead) {
+    return finishFailed(request, state, workerContext, "snapshot_changed", {
+      exitCode: childResult.code,
+      expectedHead: state.snapshotHead,
+      actualHead: currentHead,
+    });
+  }
+
+  const validation = validateBundle(repo, request.validatorPath);
+  if (!validation.ok) {
+    return finishFailed(request, state, workerContext, "artifact_validation_failed", {
+      exitCode: childResult.code,
+      validationExitCode: validation.exitCode,
+      validationError: validation.error,
+    });
+  }
+
+  const profileHead = profileLocalHead(join(repo, ".repo_memory", "PROFILE.md"));
+  const resolvedProfileHead = profileHead ? resolveCommit(repo, profileHead) : undefined;
+  if (!resolvedProfileHead || resolvedProfileHead !== state.snapshotHead) {
+    return finishFailed(request, state, workerContext, "profile_head_mismatch", {
+      exitCode: childResult.code,
+      profileHead,
+      resolvedProfileHead,
+      expectedHead: state.snapshotHead,
+    });
+  }
+
+  return finishSucceeded(request, state, workerContext, {
+    exitCode: childResult.code,
+    profileHead: resolvedProfileHead,
+    validationExitCode: validation.exitCode,
+  });
+}
+
+function recordUnhandledFailure(error) {
+  if (!activeRequest || !activeWorkerContext) return false;
+  try {
+    const state = readJobState(activeRequest.jobPath);
+    assertJobIdentity(state, {
+      repo: activeRequest.repo,
+      jobId: activeWorkerContext.jobId,
+      runId: activeWorkerContext.runId,
+    });
+    if (state.status === "succeeded" || state.status === "failed") {
+      removeOwnedMarker(activeRequest, state, activeWorkerContext);
+      return true;
+    }
+    finishFailed(
+      activeRequest,
+      state,
+      activeWorkerContext,
+      requestedSignal ? "worker_interrupted" : "worker_internal_error",
+      { error: errorMessage(error), signal: requestedSignal },
+    );
+    return true;
+  } catch (recordError) {
+    process.stderr.write(
+      `repo memory worker failed: ${errorMessage(error)}; could not record terminal state: ${errorMessage(recordError)}\n`,
+    );
+    return false;
+  }
+}
+
+function parseArgs(values) {
+  const result = {};
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index];
+    if (value === "--job") result.jobPath = values[++index];
+    else if (value === "--repo") result.repo = values[++index];
+    else if (value === "--memorax-code-home") result.memoraxCodeHome = values[++index];
+    else if (value === "--validator") result.validatorPath = values[++index];
+    else throw new Error(`unknown argument: ${value}`);
+  }
+  if (!result.jobPath) throw new Error("--job is required");
+  if (!result.repo) throw new Error("--repo is required");
+  if (!result.memoraxCodeHome) throw new Error("--memorax-code-home is required");
+  if (!result.validatorPath) throw new Error("--validator is required");
+  result.validatorPath = resolve(result.validatorPath);
+  return result;
+}
+
+async function waitForOwnedMarker(input) {
+  const deadline = Date.now() + 3000;
+  while (Date.now() <= deadline) {
+    if (requestedSignal) throw new Error(`worker interrupted by ${requestedSignal}`);
+    const state = readActiveRepoMemoryJobMarker({
+      memoraxCodeHome: input.memoraxCodeHome,
+      repoRealpath: input.repo,
+    });
+    if (
+      state.active
+      && state.marker.jobId === input.jobId
+      && state.marker.runId === input.runId
+      && state.marker.pid === process.pid
+    ) {
+      return;
+    }
+    await delay(25);
+  }
+  throw new Error("timed out waiting for owned repo memory job marker");
+}
+
+function runClient(command, options) {
+  return new Promise((resolveResult) => {
+    let settled = false;
+    let invocation;
+    try {
+      invocation = process.platform === "win32" && /\.[cm]?js$/i.test(command[0])
+        ? { command: process.execPath, args: command }
+        : resolveWindowsCliInvocation(command[0], command.slice(1), {
+          env: options.env,
+        });
+    } catch (error) {
+      resolveResult({ code: undefined, signal: undefined, error });
+      return;
+    }
+    let capturedStdout = "";
+    const child = spawn(invocation.command, invocation.args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: options.captureStdout ? ["ignore", "pipe", "inherit"] : "inherit",
+    });
+    activeChild = child;
+    if (Number.isInteger(child.pid) && child.pid > 0) options.onSpawn(child.pid);
+    if (options.captureStdout) {
+      child.stdout.setEncoding("utf8");
+      child.stdout.on("data", (chunk) => {
+        capturedStdout += chunk;
+        process.stdout.write(chunk);
+      });
+    }
+
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      activeChild = undefined;
+      resolveResult(result);
+    };
+    child.once("error", (error) => finish({ code: undefined, signal: undefined, error }));
+    child.once("close", (code, signal) => {
+      if (options.captureStdout) {
+        try {
+          writeFileSync(options.finalMessagePath, capturedStdout, { mode: 0o600 });
+        } catch (error) {
+          finish({ code, signal, error });
+          return;
+        }
+      }
+      finish({ code, signal, error: undefined });
+    });
+    if (requestedSignal) child.kill(requestedSignal);
+  });
+}
+
+function validateBundle(repo, validator) {
+  const python = process.env.MEMORAX_CODE_REPO_MEMORY_PYTHON_COMMAND || "python3";
+  process.stdout.write("\n[repo-memory-worker] validating generated repo memory\n");
+  const result = spawnSync(python, [validator, repo, "--pretty"], {
+    cwd: repo,
+    encoding: "utf8",
+    env: process.env,
+  });
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  return {
+    ok: !result.error && result.status === 0,
+    exitCode: result.status,
+    error: result.error instanceof Error ? result.error.message : undefined,
+  };
+}
+
+function finishSucceeded(request, state, workerContext, details) {
+  try {
+    writeJobState(request.jobPath, {
+      ...state,
+      status: "succeeded",
+      finishedAt: new Date().toISOString(),
+      exitCode: details.exitCode,
+      validation: {
+        ok: true,
+        exitCode: details.validationExitCode,
+        profileHead: details.profileHead,
+      },
+    });
+    process.stdout.write("[repo-memory-worker] job succeeded\n");
+    return true;
+  } finally {
+    removeOwnedMarker(request, state, workerContext);
+  }
+}
+
+function finishFailed(request, state, workerContext, failureReason, details = {}) {
+  try {
+    writeJobState(request.jobPath, {
+      ...state,
+      status: "failed",
+      finishedAt: new Date().toISOString(),
+      failureReason,
+      ...definedEntries(details),
+    });
+    process.stderr.write(`[repo-memory-worker] job failed: ${failureReason}\n`);
+    return false;
+  } finally {
+    removeOwnedMarker(request, state, workerContext);
+  }
+}
+
+function removeOwnedMarker(request, state, workerContext) {
+  removeRepoMemoryJobMarkerIfOwned({
+    memoraxCodeHome: request.memoraxCodeHome,
+    repoRealpath: state.repo,
+    jobId: workerContext.jobId,
+    runId: workerContext.runId,
+  });
+}
+
+function readJobState(path) {
+  const result = readJsonFile(path);
+  if (!result?.value || result.unreadable) throw new Error(`repo memory job state is unreadable: ${path}`);
+  return result.value;
+}
+
+function writeJobState(path, state) {
+  atomicWriteJson(path, state);
+  return state;
+}
+
+function assertJobIdentity(state, expected) {
+  if (state.jobId !== expected.jobId) throw new Error("repo memory job id does not match worker context");
+  if (state.runId !== expected.runId) throw new Error("repo memory job run id does not match worker context");
+  if (state.repo !== expected.repo) throw new Error("repo memory job repository does not match worker context");
+}
+
+function normalizedCommand(value) {
+  if (!Array.isArray(value) || value.length === 0 || value.some((entry) => typeof entry !== "string" || !entry)) {
+    throw new Error("repo memory job command is invalid");
+  }
+  return value;
+}
+
+function runnerName(value) {
+  const runner = stringOption(value) || "codex";
+  if (!/^[a-z][a-z0-9-]*$/.test(runner)) {
+    throw new Error("repo memory job runner is invalid");
+  }
+  return runner;
+}
+
+function finalMessageSource(value) {
+  const source = stringOption(value) || "file";
+  if (source !== "file" && source !== "stdout") {
+    throw new Error("repo memory job final message source is invalid");
+  }
+  return source;
+}
+
+function nonEmptyFile(path) {
+  try {
+    return existsSync(path) && readFileSync(path, "utf8").trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function profileLocalHead(path) {
+  try {
+    const text = readFileSync(path, "utf8").replace(/^\uFEFF/, "");
+    const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
+    if (!match) return undefined;
+    const line = match[1].split(/\r?\n/).find((entry) => /^local_head\s*:/.test(entry.trim()));
+    return stringOption(line?.replace(/^\s*local_head\s*:\s*/, "").trim().replace(/^['"]|['"]$/g, ""));
+  } catch {
+    return undefined;
+  }
+}
+
+function resolveCommit(repo, ref) {
+  const result = spawnSync("git", ["rev-parse", "--verify", `${ref}^{commit}`], {
+    cwd: repo,
+    encoding: "utf8",
+  });
+  return result.status === 0 ? result.stdout.trim() : undefined;
+}
+
+function gitHead(repo) {
+  const head = resolveCommit(repo, "HEAD");
+  if (!head) throw new Error(`git could not resolve HEAD in ${repo}`);
+  return head;
+}
+
+function definedEntries(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined && entry !== null));
+}
+
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function delay(ms) {
+  return new Promise((resolveDelay) => setTimeout(resolveDelay, ms));
+}

package/lib/memorax-code-adapter-common/src/repo-memory/repo-memory-update-policy-evaluator.mjs

@@ -0,0 +1,185 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import {
+  evaluateRepoMemoryUpdatePolicy,
+  parseRepoMemoryUpdatePolicyConfig,
+} from "./repo-memory-update-policy.mjs";
+
+export function runRepoMemoryUpdatePolicy(args) {
+  return evaluateRepository(parseArgs(args));
+}
+
+export function evaluateRepository(input) {
+  const repo = repositoryRoot(input.repo);
+  const profilePath = join(repo, ".repo_memory", "PROFILE.md");
+  if (!existsSync(profilePath)) {
+    throw new Error(`repo memory update policy requires .repo_memory/PROFILE.md: ${repo}`);
+  }
+
+  const profileStat = statSync(profilePath);
+  if (!profileStat.isFile()) throw new Error(`repo memory profile is not a regular file: ${profilePath}`);
+  const profile = parseFrontmatter(readFileSync(profilePath, "utf8"));
+  const head = git(repo, ["rev-parse", "HEAD"]);
+  const baseline = stringValue(profile.local_head);
+  const baselineState = inspectBaseline(repo, baseline, head);
+  const lastUpdate = profileUpdateTime(profile, profileStat.mtimeMs);
+  const config = resolvedConfig(input);
+  const pullRequestDetected = baselineState.status === "ancestor" && baselineState.commitsBehind > 0
+    ? pendingRangeContainsPullRequest(repo, baseline, head)
+    : false;
+  const decision = evaluateRepoMemoryUpdatePolicy({
+    ...config,
+    baselineStatus: baselineState.status,
+    commitsBehind: baselineState.commitsBehind,
+    pullRequestDetected,
+    lastUpdatedAtMs: lastUpdate.atMs,
+    nowMs: input.nowMs,
+  });
+
+  return {
+    schema: "repo_memory_update_policy_decision.v1",
+    ok: true,
+    trigger: decision.trigger,
+    reason: decision.reason,
+    policy: decision.policy,
+    policySource: decision.policySource,
+    commitThreshold: decision.commitThreshold,
+    cooldownHours: decision.cooldownHours,
+    commitsBehind: decision.commitsBehind,
+    pullRequestDetected: decision.pullRequestDetected,
+    baselineStatus: decision.baselineStatus,
+    ageHours: round(decision.ageHours),
+    lastUpdateSource: lastUpdate.source,
+    baseline,
+    head,
+  };
+}
+
+function resolvedConfig(input) {
+  const memoraxCodeHome = process.env.MEMORAX_CODE_HOME || join(homedir(), ".memorax-code");
+  const configPath = input.configPath || join(memoraxCodeHome, "config.toml");
+  const fileConfig = existsSync(configPath)
+    ? parseRepoMemoryUpdatePolicyConfig(readFileSync(configPath, "utf8"))
+    : {};
+  return {
+    policy: stringValue(process.env.MEMORAX_CODE_REPO_MEMORY_UPDATE_POLICY) ?? fileConfig.policy,
+    commitThreshold: process.env.MEMORAX_CODE_REPO_MEMORY_STALE_COMMIT_THRESHOLD
+      ?? fileConfig.commitThreshold,
+    cooldownHours: process.env.MEMORAX_CODE_REPO_MEMORY_UPDATE_COOLDOWN_HOURS
+      ?? fileConfig.cooldownHours,
+  };
+}
+
+function inspectBaseline(repo, baseline, head) {
+  if (!baseline) return { status: "missing", commitsBehind: Number.MAX_SAFE_INTEGER };
+  if (gitMaybe(repo, ["rev-parse", "--verify", `${baseline}^{commit}`]) === undefined) {
+    return { status: "not_ancestor", commitsBehind: Number.MAX_SAFE_INTEGER };
+  }
+  if (!gitSuccess(repo, ["merge-base", "--is-ancestor", baseline, head])) {
+    return { status: "not_ancestor", commitsBehind: Number.MAX_SAFE_INTEGER };
+  }
+  const count = Number(git(repo, ["rev-list", "--count", `${baseline}..${head}`]));
+  return {
+    status: "ancestor",
+    commitsBehind: Number.isInteger(count) && count >= 0 ? count : Number.MAX_SAFE_INTEGER,
+  };
+}
+
+function pendingRangeContainsPullRequest(repo, baseline, head) {
+  const messages = gitMaybe(repo, ["log", "--format=%s%n%b%x00", `${baseline}..${head}`]) || "";
+  return messages.split("\x00").some((message) => (
+    /\(#\d+\)\s*$/m.test(message)
+    || /^Merge pull request #\d+\b/m.test(message)
+    || /See merge request .+!\d+\b/m.test(message)
+  ));
+}
+
+function profileUpdateTime(profile, mtimeMs) {
+  for (const field of ["generated_at", "updated_at", "last_updated_at"]) {
+    const raw = stringValue(profile[field]);
+    const atMs = Date.parse(raw || "");
+    if (Number.isFinite(atMs)) return { atMs, source: `profile.${field}` };
+  }
+  return { atMs: mtimeMs, source: "profile.mtime" };
+}
+
+function parseFrontmatter(text) {
+  const match = String(text).match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  if (!match) return {};
+  const result = {};
+  for (const rawLine of match[1].split(/\r?\n/)) {
+    const field = rawLine.match(/^([A-Za-z0-9_]+)\s*:\s*(.*?)\s*$/);
+    if (!field) continue;
+    result[field[1]] = field[2].replace(/^['"]|['"]$/g, "");
+  }
+  return result;
+}
+
+function repositoryRoot(path) {
+  const candidate = realpathSync(resolve(path));
+  const root = git(candidate, ["rev-parse", "--show-toplevel"]);
+  return realpathSync(root);
+}
+
+function git(repo, args) {
+  return execFileSync("git", args, {
+    cwd: repo,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  }).trim();
+}
+
+function gitMaybe(repo, args) {
+  try {
+    return git(repo, args);
+  } catch {
+    return undefined;
+  }
+}
+
+function gitSuccess(repo, args) {
+  try {
+    execFileSync("git", args, {
+      cwd: repo,
+      encoding: "utf8",
+      stdio: ["ignore", "ignore", "ignore"],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function parseArgs(args) {
+  if (args[0] !== "evaluate") {
+    throw new Error("usage: repo-memory-update-policy.mjs evaluate --repo PATH [--now ISO8601] [--config PATH]");
+  }
+  const input = {};
+  for (let index = 1; index < args.length; index += 1) {
+    const value = args[index];
+    if (value === "--repo") input.repo = requiredValue(args, ++index, value);
+    else if (value === "--now") {
+      input.nowMs = Date.parse(requiredValue(args, ++index, value));
+      if (!Number.isFinite(input.nowMs)) throw new Error("--now must be ISO8601");
+    } else if (value === "--config") input.configPath = resolve(requiredValue(args, ++index, value));
+    else throw new Error(`unknown argument: ${value}`);
+  }
+  if (!input.repo) throw new Error("--repo is required");
+  return input;
+}
+
+function requiredValue(values, index, flag) {
+  const value = values[index];
+  if (!value || value.startsWith("--")) throw new Error(`${flag} requires a value`);
+  return value;
+}
+
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function round(value) {
+  return Number.isFinite(value) ? Math.round(value * 100) / 100 : undefined;
+}