@memorax/memorax-code 0.1.9 → 0.1.11

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

@@ -21,7 +21,7 @@ let requestedSignal;
 for (const signal of ["SIGINT", "SIGTERM"]) {
   process.on(signal, () => {
     requestedSignal = signal;
-    activeChild?.kill(signal);
+    if (activeChild) terminateClient(activeChild, signal);
   });
 }
 
@@ -56,12 +56,16 @@ async function main(args) {
     runId: workerContext.runId,
   });
   if (initial.status !== "started") throw new Error(`repo memory job cannot start from status ${initial.status}`);
+  const clientTimeoutMs = repoMemoryClientTimeoutMs();
+  const clientKillGraceMs = repoMemoryClientKillGraceMs();
   let state = writeJobState(request.jobPath, {
     ...initial,
     status: "running",
     pid: process.pid,
     workerPid: process.pid,
     workerStartedAt: new Date().toISOString(),
+    clientTimeoutMs,
+    clientKillGraceMs,
   });
 
   if (requestedSignal) {
@@ -85,9 +89,18 @@ async function main(args) {
       });
     },
     finalMessagePath: state.finalMessagePath,
+    timeoutMs: clientTimeoutMs,
+    killGraceMs: clientKillGraceMs,
   });
   state = readJobState(request.jobPath);
 
+  if (childResult.timedOut) {
+    return finishFailed(request, state, workerContext, `${runner}_timeout`, {
+      timeoutMs: childResult.timeoutMs,
+      elapsedMs: childResult.elapsedMs,
+      signal: childResult.signal,
+    });
+  }
   if (childResult.error) {
     return finishFailed(request, state, workerContext, `${runner}_spawn_failed`, {
       error: childResult.error.message,
@@ -213,6 +226,11 @@ async function waitForOwnedMarker(input) {
 function runClient(command, options) {
   return new Promise((resolveResult) => {
     let settled = false;
+    let timeoutHandle;
+    let killHandle;
+    let timedOut = false;
+    let timeoutMs;
+    const startedAt = Date.now();
     let invocation;
     try {
       invocation = process.platform === "win32" && /\.[cm]?js$/i.test(command[0])
@@ -228,6 +246,7 @@ function runClient(command, options) {
     const child = spawn(invocation.command, invocation.args, {
       cwd: options.cwd,
       env: options.env,
+      detached: process.platform !== "win32",
       stdio: options.captureStdout ? ["ignore", "pipe", "inherit"] : "inherit",
     });
     activeChild = child;
@@ -243,8 +262,10 @@ function runClient(command, options) {
     const finish = (result) => {
       if (settled) return;
       settled = true;
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+      if (killHandle) clearTimeout(killHandle);
       activeChild = undefined;
-      resolveResult(result);
+      resolveResult({ ...result, timedOut, timeoutMs, elapsedMs: Date.now() - startedAt });
     };
     child.once("error", (error) => finish({ code: undefined, signal: undefined, error }));
     child.once("close", (code, signal) => {
@@ -258,10 +279,74 @@ function runClient(command, options) {
       }
       finish({ code, signal, error: undefined });
     });
-    if (requestedSignal) child.kill(requestedSignal);
+    if (Number.isFinite(options.timeoutMs) && options.timeoutMs > 0) {
+      timeoutHandle = setTimeout(() => {
+        timeoutMs = options.timeoutMs;
+        timedOut = true;
+        const terminated = terminateClient(child, "SIGTERM");
+        // A broken or ignored CLI must not leave a detached job behind forever.
+        // The grace period is deliberately short and only targets this child.
+        killHandle = setTimeout(() => {
+          if (!settled) terminateClient(child, "SIGKILL");
+        }, options.killGraceMs);
+        if (!terminated && !settled) {
+          finish({
+            code: undefined,
+            signal: "SIGTERM",
+            error: undefined,
+            timedOut: true,
+            timeoutMs,
+          });
+        }
+      }, options.timeoutMs);
+    }
+    if (requestedSignal) terminateClient(child, requestedSignal);
   });
 }
 
+function terminateClient(child, signal) {
+  if (!child || !Number.isInteger(child.pid) || child.pid <= 0) return false;
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-child.pid, signal);
+      return true;
+    } catch {
+      // The process group may have exited between the timeout and this call.
+    }
+  }
+  if (process.platform === "win32") {
+    try {
+      const result = spawnSync("taskkill", ["/PID", String(child.pid), "/T", "/F"], {
+        encoding: "utf8",
+        windowsHide: true,
+        stdio: ["ignore", "ignore", "ignore"],
+      });
+      if (result.status === 0) return true;
+    } catch {
+      // Fall through to the direct child termination below.
+    }
+  }
+  try {
+    return child.kill(signal);
+  } catch {
+    return false;
+  }
+}
+
+function repoMemoryClientTimeoutMs(env = process.env) {
+  return positiveEnvInteger(env.MEMORAX_CODE_REPO_MEMORY_JOB_TIMEOUT_MS, 10 * 60 * 1000);
+}
+
+function repoMemoryClientKillGraceMs(env = process.env) {
+  return positiveEnvInteger(env.MEMORAX_CODE_REPO_MEMORY_JOB_KILL_GRACE_MS, 5000);
+}
+
+function positiveEnvInteger(value, fallback) {
+  if (typeof value !== "string" || !/^\d+$/.test(value.trim())) return fallback;
+  const parsed = Number(value.trim());
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+
 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");

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/windows-cli-invocation.mjs

@@ -24,6 +24,9 @@ export function resolveWindowsCliInvocation(command, args, options = {}) {
   }
   resolvedCommand ??= command;
   if (/\.(?:exe|com)$/i.test(resolvedCommand)) return { command: resolvedCommand, args };
+  if (isBareCodeBuddyEntrypoint(resolvedCommand, pathApi) && fileExists(resolvedCommand)) {
+    return { command: options.nodePath ?? process.execPath, args: [resolvedCommand, ...args] };
+  }
   if (!/\.(?:cmd|bat)$/i.test(resolvedCommand)) {
     throw new Error(`refusing to execute unsupported Windows command shim: ${resolvedCommand}`);
   }
@@ -104,9 +107,16 @@ export function selectWindowsCommandCandidate(command, output) {
     .map((value) => value.trim())
     .filter(Boolean);
   const selected = candidates.find((value) => /\.(?:cmd|bat)$/i.test(value))
-    ?? candidates.find((value) => /\.(?:exe|com)$/i.test(value));
+    ?? candidates.find((value) => /\.(?:exe|com)$/i.test(value))
+    ?? (path.win32.basename(command).toLowerCase() === "codebuddy"
+      ? candidates.find((value) => isBareCodeBuddyEntrypoint(value, path.win32))
+      : undefined);
   if (!selected) {
     throw new Error(`where.exe did not return a safe executable or command shim for ${command}`);
   }
   return selected;
 }
+
+function isBareCodeBuddyEntrypoint(value, pathApi) {
+  return pathApi.basename(value).toLowerCase() === "codebuddy" && pathApi.extname(value) === "";
+}

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memorax-code/claude-adapter",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "private": true,
   "type": "module",
   "description": "Claude Code Hook adapter for MemoraX Code memory services.",

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/runtime-hooks/ensure-backend.mjs

@@ -2,6 +2,7 @@
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { readClientHookPluginRoot } from "../memorax-code-adapter-common/src/config-utils.mjs";
 import {
   runEnsureBackendHook,
   stringValue,
@@ -31,6 +32,7 @@ process.exit(0);
 function pluginRoot() {
   return stringValue(process.env.CLAUDE_PLUGIN_ROOT)
     ?? stringValue(process.env.PLUGIN_ROOT)
+    ?? readClientHookPluginRoot()
     ?? dirname(dirname(fileURLToPath(import.meta.url)));
 }
 

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/src/plugin-install.mjs

@@ -32,6 +32,7 @@ const STABLE_SHELL_REQUIRED_FILES = Object.freeze([
   "memorax-code-adapter-common/src/hooks/capture-cwd-hook.mjs",
   "memorax-code-adapter-common/src/hooks/client-hook-launcher.mjs",
   "memorax-code-adapter-common/src/config-utils.mjs",
+  "memorax-code-adapter-common/src/setup-completion.mjs",
   "memorax-code-adapter-common/src/hooks/ensure-backend-runner.mjs",
   "memorax-code-adapter-common/src/hooks/hook-runtime-generation.mjs",
   "memorax-code-adapter-common/src/hooks/memory-skill-reminder-hook.mjs",
@@ -226,10 +227,12 @@ export function ensureClaudePluginInstalled(options = {}) {
 }
 
 function writeInstalledPluginMetadata(installPath, claudeCommand) {
+  const npmExecPath = stringOption(process.env.MEMORAX_CODE_NPM_EXEC_PATH);
   atomicWriteJson(join(installPath, ".memorax-code-package.json"), {
     version: 1,
     memoraxCodeCommand: process.argv[1],
     claudeCommand,
+    ...(npmExecPath ? { npmExecPath } : {}),
     writtenAt: new Date().toISOString(),
   });
 }

package/lib/memorax-code-codebuddy-adapter/.codebuddy-plugin/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "memorax-code-codebuddy-adapter",
+  "version": "0.1.11",
+  "description": "MemoraX Code memory integration for CodeBuddy and WorkBuddy.",
+  "hooks": "./hooks/hooks.json",
+  "skills": ["./skills/memorax-code"]
+}

package/lib/memorax-code-codebuddy-adapter/hooks/common-runtime.mjs

@@ -0,0 +1,13 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+export function resolveCommonSourceRoot(pluginRoot) {
+  const candidates = [
+    join(pluginRoot, "memorax-code-adapter-common", "src"),
+    join(pluginRoot, "..", "memorax-code-adapter-common", "src"),
+    join(pluginRoot, "..", "..", "memorax-code-adapter-common", "src"),
+  ];
+  const root = candidates.find((candidate) => existsSync(join(candidate, "repo-memory", "repo-memory-job-supervisor.mjs")));
+  if (!root) throw new Error(`MemoraX Code shared runtime is unavailable for CodeBuddy plugin: ${pluginRoot}`);
+  return root;
+}

package/lib/memorax-code-codebuddy-adapter/hooks/hooks.json

@@ -0,0 +1,38 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CODEBUDDY_PLUGIN_ROOT}/hooks/runtime-hook.mjs\" turn",
+            "timeout": 35
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CODEBUDDY_PLUGIN_ROOT}/hooks/runtime-hook.mjs\" turn",
+            "timeout": 15
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CODEBUDDY_PLUGIN_ROOT}/hooks/runtime-hook.mjs\" turn",
+            "timeout": 15
+          }
+        ]
+      }
+    ]
+  }
+}

package/lib/memorax-code-codebuddy-adapter/hooks/repo-memory-job.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { pathToFileURL } from "node:url";
+import { resolveCommonSourceRoot } from "./common-runtime.mjs";
+
+const hookDir = dirname(fileURLToPath(import.meta.url));
+const pluginRoot = dirname(hookDir);
+const commonRoot = resolveCommonSourceRoot(pluginRoot);
+const { resolveHookCodeBuddyCommand } = await import(pathToFileURL(join(commonRoot, "clients", "codebuddy-command.mjs")).href);
+const { runRepoMemoryJob } = await import(pathToFileURL(join(commonRoot, "repo-memory", "repo-memory-job-supervisor.mjs")).href);
+const { evaluateRepository } = await import(pathToFileURL(join(commonRoot, "repo-memory", "repo-memory-update-policy-evaluator.mjs")).href);
+
+try {
+  const payload = runRepoMemoryJob(process.argv.slice(2), {
+    runner: "codebuddy",
+    finalMessageSource: "stdout",
+    memorySkillInvocation: "the `memorax-code` skill",
+    validatorPath: resolve(pluginRoot, "skills/memorax-code/scripts/validate_memory.py"),
+    evaluateRepository,
+    createCommand({ prompt }) {
+      const codeBuddy = resolveHookCodeBuddyCommand({
+        pluginRoot,
+      });
+      return [
+        codeBuddy,
+        "--print",
+        "--output-format",
+        "text",
+        "--dangerously-skip-permissions",
+        "--no-session-persistence",
+        prompt,
+      ];
+    },
+  });
+  process.stdout.write(`${JSON.stringify(payload)}\n`);
+} catch (error) {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  process.exit(1);
+}

package/lib/memorax-code-codebuddy-adapter/hooks/runtime-hook.mjs

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { appendFile, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { pathToFileURL } from "node:url";
+import { resolveCommonSourceRoot } from "./common-runtime.mjs";
+import { writeCodeBuddyRuntimeObservation } from "../src/runtime-observation.mjs";
+
+const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const commonRoot = resolveCommonSourceRoot(pluginRoot);
+const { scheduleMissingRepoMemoryBuild } = await import(pathToFileURL(join(commonRoot, "repo-memory", "repo-memory-auto-build.mjs")).href);
+const { isRepoMemoryJobWorker } = await import(pathToFileURL(join(commonRoot, "repo-memory", "repo-memory-job-context.mjs")).href);
+const { buildRepoProcedureMemoryContext } = await import(pathToFileURL(join(commonRoot, "repo-memory", "repo-procedure-memory-context.mjs")).href);
+const { buildRepoUserProfilePreferencesContext } = await import(pathToFileURL(join(commonRoot, "repo-memory", "repo-user-profile-context.mjs")).href);
+const { resolveBackendConnection } = await import(pathToFileURL(join(commonRoot, "backend-connection.mjs")).href);
+const { ensureBackendAvailable, stringValue: commonStringValue } = await import(pathToFileURL(join(commonRoot, "hooks", "ensure-backend-runner.mjs")).href);
+const {
+  evaluateMemorySkillReminder,
+  markSupplementalReminderAfterCompact,
+  personalMemoryReminderContext,
+} = await import(pathToFileURL(join(commonRoot, "hooks", "memory-skill-reminder-hook.mjs")).href);
+
+if (isRepoMemoryJobWorker()) process.exit(0);
+
+const MEMORY_SKILL_INVOCATION = "the `memorax-code` skill";
+const REMINDER_TRACE_TIMEOUT_MS = 1000;
+
+const input = await readJsonStdin();
+const event = stringValue(input?.hook_event_name) ?? stringValue(input?.hookEventName);
+const sessionId = stringValue(input?.session_id) ?? stringValue(input?.sessionId);
+const transcriptPath = stringValue(input?.transcript_path) ?? stringValue(input?.transcriptPath);
+if (!event || !sessionId || !transcriptPath) process.exit(0);
+const home = process.env.MEMORAX_CODE_HOME?.trim() || join(homedir(), ".memorax-code");
+const packageMetadata = await readRecord(join(pluginRoot, ".memorax-code-package.json"));
+const codeBuddyHome = commonStringValue(process.env.CODEBUDDY_HOME)
+  ?? commonStringValue(process.env.WORKBUDDY_HOME)
+  ?? commonStringValue(packageMetadata.codeBuddyHome)
+  ?? commonStringValue(input?.codebuddy_home)
+  ?? commonStringValue(input?.codeBuddyHome)
+  ?? defaultCodeBuddyHome();
+try {
+  await writeCodeBuddyRuntimeObservation({ memoraxCodeHome: home, codeBuddyHome, pluginRoot });
+} catch (error) {
+  if (process.env.MEMORAX_CODE_CODEBUDDY_HOOK_DEBUG === "1") {
+    console.error(error instanceof Error ? error.message : String(error));
+  }
+}
+const pendingPath = join(home, "adapters", "codebuddy", "pending.json");
+const reminderOptions = {
+  adapterDir: "codebuddy",
+  debugEnv: "MEMORAX_CODE_CODEBUDDY_HOOK_DEBUG",
+  memoraxCodeHome: home,
+  runtime: "codebuddy",
+  supplementalReminderAfterCompact: true,
+};
+const personalMemoryContextOptions = {
+  adapterDir: "codebuddy",
+  debugEnv: "MEMORAX_CODE_CODEBUDDY_HOOK_DEBUG",
+  sessionKeyPrefix: "codebuddy",
+};
+if (event === "SessionStart") await bindMemoryCliTraceSession(sessionId);
+await ensureBackendAvailable({
+  ensureBackendValue: process.env.MEMORAX_CODE_CODEBUDDY_ENSURE_BACKEND
+    ?? process.env.MEMORAX_CODE_CODEBUDDY_HOOK_ENSURE_BACKEND,
+  healthTimeoutValue: process.env.MEMORAX_CODE_CODEBUDDY_ENSURE_TIMEOUT_MS,
+  startTimeoutValue: process.env.MEMORAX_CODE_CODEBUDDY_START_TIMEOUT_MS,
+  memoraxCodeCommand: commonStringValue(process.env.MEMORAX_CODE_CODEBUDDY_LIFECYCLE_COMMAND)
+    ?? commonStringValue(process.env.MEMORAX_CODE_COMMAND),
+  pluginRoot,
+  resolveHomes: () => ({
+    memoraxCodeHome: home,
+    codeBuddyHome,
+  }),
+  buildStartArgs: (homes, recoveryArguments) => [
+    "start",
+    "--home", homes.memoraxCodeHome,
+    "--clients", "codebuddy",
+    "--codebuddy-home", homes.codeBuddyHome,
+    ...recoveryArguments,
+  ],
+  debug: (message) => { if (process.env.MEMORAX_CODE_CODEBUDDY_HOOK_DEBUG === "1") console.error(message); },
+}, input);
+if (event === "SessionStart") {
+  markSupplementalReminderAfterCompact(reminderOptions, input);
+} else if (event === "UserPromptSubmit") {
+  const prompt = stringValue(input.prompt);
+  if (!prompt) process.exit(0);
+  const boundary = await fileBoundary(transcriptPath);
+  const turnId = provisionalTurnId(sessionId, boundary, prompt);
+  const workspaceKind = stringValue(input.workspace_kind) ?? stringValue(input.workspaceKind);
+  await updatePending(pendingPath, (state) => {
+    const now = Date.now();
+    const existing = state[sessionId];
+    state[sessionId] = {
+      version: 1,
+      turnId,
+      transcriptPath,
+      cwd: stringValue(input.cwd),
+      workspaceKind,
+      createdAt: existing?.turnId === turnId ? existing.createdAt : now,
+      updatedAt: now,
+    };
+  });
+  const response = await post("/memory/turn-start", { version: 1, client: "codebuddy", sessionId, turnId, transcriptPath, prompt, cwd: stringValue(input.cwd), workspaceKind });
+  const repoMemoryWorktree = stringValue(response?.repoMemoryWorktree);
+  scheduleMissingRepoMemoryBuild(repoMemoryWorktree, {
+    debugEnv: "MEMORAX_CODE_CODEBUDDY_HOOK_DEBUG",
+    pluginRoot,
+  });
+  const reminderResult = await evaluateMemorySkillReminder({
+    ...reminderOptions,
+    additionalReminderContext: personalMemoryReminderContext(MEMORY_SKILL_INVOCATION),
+    memorySkillInvocation: MEMORY_SKILL_INVOCATION,
+    remindOnFirstTurn: true,
+    requireTranscriptPath: true,
+    ...(repoMemoryWorktree ? {
+      buildCadenceReminderContext: (hookInput) => buildRepoProcedureMemoryContext({
+        ...hookInput,
+        cwd: repoMemoryWorktree,
+      }, personalMemoryContextOptions),
+      buildPersonalMemoryContext: (hookInput) => buildRepoUserProfilePreferencesContext({
+        ...hookInput,
+        cwd: repoMemoryWorktree,
+      }, personalMemoryContextOptions),
+    } : {}),
+  }, { ...input, turnId, workspaceKind });
+  const context = [
+    stringValue(response?.additionalContext),
+    stringValue(reminderResult?.additionalContext),
+  ].filter(Boolean).join("\n\n");
+  const systemMessage = stringValue(response?.userNotice);
+  if (context || systemMessage) process.stdout.write(`${JSON.stringify({
+    ...(systemMessage ? { systemMessage } : {}),
+    ...(context ? { hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: context } } : {}),
+  })}\n`);
+  if (response !== undefined && reminderResult?.reminder) await recordReminder(reminderResult.reminder);
+} else if (event === "Stop") {
+  const record = (await readPending(pendingPath))[sessionId];
+  if (!record || record.transcriptPath !== transcriptPath) process.exit(0);
+  const response = await post("/memory/writeback", { version: 1, client: "codebuddy", sessionId, turnId: record.turnId, transcriptPath, cwd: record.cwd ?? stringValue(input.cwd), workspaceKind: record.workspaceKind ?? stringValue(input.workspaceKind) });
+  if (response?.ok === true && response?.scheduled === true) {
+    await updatePending(pendingPath, (state) => {
+      if (state[sessionId]?.turnId === record.turnId) delete state[sessionId];
+    });
+  }
+}
+
+async function recordReminder(reminder) {
+  if (!reminder.turnId || !reminder.transcriptPath) return;
+  await post("/memory/skill-reminder", {
+    version: 1,
+    client: "codebuddy",
+    sessionId: reminder.sessionId,
+    turnId: reminder.turnId,
+    transcriptPath: reminder.transcriptPath,
+    cwd: reminder.cwd,
+    workspaceKind: reminder.workspaceKind,
+    content: reminder.content,
+    triggers: reminder.triggers,
+  }, REMINDER_TRACE_TIMEOUT_MS);
+}
+
+async function post(path, body, timeoutMs = 12_000) {
+  let connection;
+  try {
+    connection = resolveBackendConnection({ memoraxCodeHome: home });
+  } catch (error) {
+    if (process.env.MEMORAX_CODE_CODEBUDDY_HOOK_DEBUG === "1") console.error(error instanceof Error ? error.message : String(error));
+    return undefined;
+  }
+  const headers = { "content-type": "application/json", connection: "close" };
+  if (connection.token) headers["x-memorax-code-backend-token"] = connection.token;
+  try { const response = await fetch(new URL(path, connection.url), { method: "POST", headers, body: JSON.stringify(body), signal: AbortSignal.timeout(timeoutMs) }); return response.ok ? await response.json().catch(() => undefined) : undefined; } catch { return undefined; }
+}
+async function fileBoundary(path) { try { return (await stat(path)).size; } catch { return 0; } }
+async function readJsonStdin() { try { let text = ""; for await (const chunk of process.stdin) text += chunk; return JSON.parse(text); } catch { return {}; } }
+async function readRecord(path) { try { const value = JSON.parse(await readFile(path, "utf8")); return value && typeof value === "object" && !Array.isArray(value) ? value : {}; } catch { return {}; } }
+async function writeRecord(path, value) { await mkdir(dirname(path), { recursive: true }); await writeFile(path, `${JSON.stringify(value)}\n`, { mode: 0o600 }); }
+async function readPending(path) {
+  return await withJsonFileLockAsync(path, async () => {
+    const state = await readRecord(path);
+    prunePendingState(state);
+    await writeRecord(path, state);
+    return state;
+  });
+}
+async function updatePending(path, mutate) {
+  await withJsonFileLockAsync(path, async () => {
+    const state = await readRecord(path);
+    prunePendingState(state);
+    mutate(state);
+    prunePendingState(state);
+    await writeRecord(path, state);
+  });
+}
+async function withJsonFileLockAsync(path, operation) {
+  const lockPath = `${path}.lock`;
+  const deadline = Date.now() + 1500;
+  let acquired = false;
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  while (!acquired) {
+    try {
+      await mkdir(lockPath, { recursive: false, mode: 0o700 });
+      acquired = true;
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+      try {
+        const lock = await stat(lockPath);
+        if (Date.now() - lock.mtimeMs > 30_000) await rm(lockPath, { recursive: true, force: true });
+      } catch {}
+      if (Date.now() >= deadline) {
+        const timeout = new Error(`timed out waiting for CodeBuddy Hook state lock: ${lockPath}`);
+        timeout.code = "JSON_FILE_LOCK_TIMEOUT";
+        throw timeout;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+  }
+  try { return await operation(); } finally { await rm(lockPath, { recursive: true, force: true }); }
+}
+async function bindMemoryCliTraceSession(sessionId) {
+  const envFile = stringValue(process.env.CODEBUDDY_ENV_FILE);
+  if (!envFile) return;
+  try {
+    await appendFile(envFile, [
+      "export MEMORAX_CODE_MEMORY_CLI_TRACE_CLIENT='codebuddy'",
+      `export MEMORAX_CODE_MEMORY_CLI_TRACE_SESSION_ID=${shellSingleQuote(sessionId)}`,
+      "",
+    ].join("\n"), "utf8");
+  } catch (error) {
+    if (process.env.MEMORAX_CODE_CODEBUDDY_HOOK_DEBUG === "1") {
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+  }
+}
+function shellSingleQuote(value) { return `'${value.replaceAll("'", "'\"'\"'")}'`; }
+function stringValue(value) { return typeof value === "string" && value.trim() ? value.trim() : undefined; }
+
+function defaultCodeBuddyHome() {
+  const workBuddyHome = join(homedir(), ".workbuddy");
+  if (process.platform !== "win32") return workBuddyHome;
+  const legacyCodeBuddyHome = join(homedir(), ".codebuddy");
+  return existsSync(workBuddyHome) || !existsSync(legacyCodeBuddyHome)
+    ? workBuddyHome
+    : legacyCodeBuddyHome;
+}
+
+function provisionalTurnId(sessionId, boundary, prompt) {
+  return `${sessionId}:${boundary}:${createHash("sha256").update(prompt.trim()).digest("hex")}`;
+}
+
+function validProvisionalTurnId(sessionId, turnId) {
+  const prefix = `${sessionId}:`;
+  if (typeof turnId !== "string" || !turnId.startsWith(prefix)) return false;
+  const match = /^(0|[1-9]\d*):[0-9a-f]{64}$/.exec(turnId.slice(prefix.length));
+  return Boolean(match && Number.isSafeInteger(Number(match[1])));
+}
+
+function prunePendingState(state) {
+  const now = Date.now();
+  const ttl = positiveInteger(process.env.MEMORAX_CODE_CODEBUDDY_PENDING_TTL_MS, 24 * 60 * 60 * 1000);
+  const maxEntries = positiveInteger(process.env.MEMORAX_CODE_CODEBUDDY_PENDING_MAX_ENTRIES, 200);
+  for (const [sessionId, record] of Object.entries(state)) {
+    if (!record || typeof record !== "object" || Array.isArray(record)) {
+      delete state[sessionId];
+      continue;
+    }
+    if (record.version !== 1 || !validProvisionalTurnId(sessionId, record.turnId) || !stringValue(record.transcriptPath)) {
+      delete state[sessionId];
+      continue;
+    }
+    if (!Number.isFinite(record.createdAt) || !Number.isFinite(record.updatedAt) || now - record.updatedAt > ttl) {
+      delete state[sessionId];
+    }
+  }
+  const entries = Object.entries(state).sort(([, left], [, right]) => Number(left.updatedAt ?? left.createdAt ?? 0) - Number(right.updatedAt ?? right.createdAt ?? 0));
+  while (entries.length > maxEntries) {
+    const [sessionId] = entries.shift();
+    delete state[sessionId];
+  }
+}
+function positiveInteger(value, fallback) {
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}

package/lib/memorax-code-codebuddy-adapter/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@memorax-code/codebuddy-adapter",
+  "version": "0.1.11",
+  "private": true,
+  "type": "module",
+  "description": "CodeBuddy and WorkBuddy Hook adapter for MemoraX Code memory services.",
+  "bin": { "memorax-code-codebuddy": "src/cli.mjs" },
+  "scripts": { "test": "node --test test/*.test.mjs" }
+}