@memorax/memorax-code 0.1.8 → 0.1.10

package/lib/memorax-code-backend/dist/memory/hook-command.js

@@ -1,4 +1,5 @@
 import { isRecord } from "../shared/record.js";
+import { codeBuddyPromptDigest, parseCodeBuddyTurnId } from "../clients/codebuddy/turn-id.js";
 export const MEMORY_HOOK_COMMAND_VERSION = 1;
 export const INVALID_MEMORY_HOOK_COMMAND = "invalid memory Hook command";
 const BASE_COMMAND_KEYS = [
@@ -13,6 +14,7 @@ const TURN_START_KEYS = {
     "claude-code": new Set([...BASE_COMMAND_KEYS, "promptId", "prompt", "transcriptPath"]),
     opencode: new Set([...BASE_COMMAND_KEYS, "userMessageId", "prompt"]),
     dsh: new Set(["version", "client", "sessionId", "turn", "startSeq", "cwd", "prompt"]),
+    codebuddy: new Set([...BASE_COMMAND_KEYS, "turnId", "prompt", "transcriptPath"]),
 };
 const WRITEBACK_KEYS = {
     codex: new Set([...BASE_COMMAND_KEYS, "turnId", "lastAssistantMessage", "transcriptPath"]),
@@ -39,12 +41,14 @@ const WRITEBACK_KEYS = {
         "sessionHeader",
         "events",
     ]),
+    codebuddy: new Set([...BASE_COMMAND_KEYS, "turnId", "transcriptPath"]),
 };
 const SKILL_REMINDER_KEYS = {
     codex: new Set([...BASE_COMMAND_KEYS, "turnId", "transcriptPath", "content", "triggers"]),
     "claude-code": new Set([...BASE_COMMAND_KEYS, "promptId", "transcriptPath", "content", "triggers"]),
     dsh: new Set(["version", "client", "sessionId", "turn", "cwd", "content", "triggers"]),
     opencode: new Set([...BASE_COMMAND_KEYS, "userMessageId", "content", "triggers"]),
+    codebuddy: new Set([...BASE_COMMAND_KEYS, "turnId", "transcriptPath", "content", "triggers"]),
 };
 export function parseTurnStartCommand(value) {
     if (!isRecord(value))
@@ -102,6 +106,13 @@ export function parseTurnStartCommand(value) {
             },
         };
     }
+    if (base.client === "codebuddy") {
+        const turnId = requiredStringField(value, "turnId");
+        const transcriptPath = requiredStringField(value, "transcriptPath");
+        if (!turnId || !transcriptPath || !validCodeBuddyTurnId(turnId, base.sessionId, prompt))
+            return invalidCommand();
+        return { ok: true, command: { ...base, client: "codebuddy", turnId, prompt, transcriptPath } };
+    }
     const promptId = requiredStringField(value, "promptId");
     const transcriptPath = requiredStringField(value, "transcriptPath");
     if (!promptId || !transcriptPath)
@@ -166,6 +177,13 @@ export function parseWritebackCommand(value) {
             },
         };
     }
+    if (base.client === "codebuddy") {
+        const turnId = requiredStringField(value, "turnId");
+        const transcriptPath = requiredStringField(value, "transcriptPath");
+        if (!turnId || !transcriptPath || !validCodeBuddyTurnId(turnId, base.sessionId))
+            return invalidCommand();
+        return { ok: true, command: { ...base, client: "codebuddy", turnId, transcriptPath } };
+    }
     const lastAssistantMessage = requiredStringField(value, "lastAssistantMessage");
     if (!lastAssistantMessage)
         return invalidCommand();
@@ -241,6 +259,13 @@ export function parseSkillReminderCommand(value) {
             },
         };
     }
+    if (base.client === "codebuddy") {
+        const turnId = requiredStringField(value, "turnId");
+        const transcriptPath = requiredStringField(value, "transcriptPath");
+        if (!turnId || !transcriptPath || !validCodeBuddyTurnId(turnId, base.sessionId))
+            return invalidCommand();
+        return { ok: true, command: { ...base, client: "codebuddy", turnId, transcriptPath, content, triggers } };
+    }
     const transcriptPath = requiredStringField(value, "transcriptPath");
     if (!transcriptPath)
         return invalidCommand();
@@ -284,7 +309,8 @@ function parseCommandBase(value, allowedKeys) {
     if (client !== "codex"
         && client !== "claude-code"
         && client !== "opencode"
-        && client !== "dsh")
+        && client !== "dsh"
+        && client !== "codebuddy")
         return undefined;
     const clientKeys = allowedKeys[client];
     if (!clientKeys || Object.keys(value).some((key) => !clientKeys.has(key)))
@@ -342,6 +368,10 @@ function optionalStringField(value, key) {
     const field = requiredStringField(value, key);
     return field ? { ok: true, value: field } : { ok: false };
 }
+function validCodeBuddyTurnId(turnId, sessionId, prompt) {
+    const identity = parseCodeBuddyTurnId({ sessionId, turnId });
+    return Boolean(identity && (prompt === undefined || identity.promptDigest === codeBuddyPromptDigest(prompt)));
+}
 function invalidCommand() {
     return { ok: false, error: INVALID_MEMORY_HOOK_COMMAND };
 }

package/lib/memorax-code-backend/dist/memory/reminder-trace-recorder.js

@@ -1,5 +1,5 @@
 import { parseSkillReminderCommand, } from "./hook-command.js";
-import { traceContextFromClaudeHookBody, traceContextFromDshSkillReminder, traceContextFromHookBody, traceContextFromOpenCodeHookBody, } from "../trace/context.js";
+import { traceContextFromClaudeHookBody, traceContextFromDshSkillReminder, traceContextFromHookBody, traceContextFromOpenCodeHookBody, traceContextFromCodeBuddyHookBody, } from "../trace/context.js";
 import { recordTraceEvent } from "../trace/store.js";
 export function createMemoryReminderTraceRecorder(options = {}) {
     return {
@@ -47,6 +47,8 @@ function traceContextForReminder(command) {
         return traceContextFromClaudeHookBody(command);
     if (command.client === "dsh")
         return traceContextFromDshSkillReminder(command);
+    if (command.client === "codebuddy")
+        return traceContextFromCodeBuddyHookBody(command);
     return traceContextFromOpenCodeHookBody(command);
 }
 function reminderSource(command) {
@@ -56,6 +58,8 @@ function reminderSource(command) {
         return "claude-hook";
     if (command.client === "dsh")
         return "dsh-cordis";
+    if (command.client === "codebuddy")
+        return "codebuddy-hook";
     return "opencode-plugin";
 }
 async function recordTraceBestEffort(label, promise, diagnosticLogger) {

package/lib/memorax-code-backend/dist/memory/service.js

@@ -3,6 +3,7 @@ import { createCodexMemoryHookRuntime, } from "../clients/codex/memory-hook-runt
 import { createClaudeMemoryHookRuntime, } from "../clients/claude/memory-hook-runtime.js";
 import { createDshMemoryHookRuntime, } from "../clients/dsh/memory-hook-runtime.js";
 import { createOpenCodeMemoryHookRuntime, } from "../clients/opencode/memory-hook-runtime.js";
+import { createCodeBuddyMemoryHookRuntime } from "../clients/codebuddy/memory-hook-runtime.js";
 import { createMemoryTurnCoordinator } from "./turn-coordinator.js";
 import { createRepositoryMemorySessionRuntime, } from "./repository-session.js";
 import { createPendingQuotaNoticeRuntime } from "./quota-notice.js";
@@ -49,6 +50,12 @@ export function createMemoryService(options = {}) {
         repositoryMemorySession,
         turnCoordinator,
     });
+    const codeBuddyHook = createCodeBuddyMemoryHookRuntime({
+        ...options,
+        pendingQuotaNotice,
+        repositoryMemorySession,
+        turnCoordinator,
+    });
     let closed = false;
     return {
         async recordTurnStart(command) {
@@ -61,6 +68,8 @@ export function createMemoryService(options = {}) {
                     return await openCodeHook.recordTurnStart(command);
                 case "dsh":
                     return await dshHook.recordTurnStart(command);
+                case "codebuddy":
+                    return await codeBuddyHook.recordTurnStart(command);
             }
             return unsupportedMemoryHookCommand(command);
         },
@@ -74,6 +83,8 @@ export function createMemoryService(options = {}) {
                     return await openCodeHook.writeback(command);
                 case "dsh":
                     return await dshHook.writeback(command);
+                case "codebuddy":
+                    return await codeBuddyHook.writeback(command);
             }
             return unsupportedMemoryHookCommand(command);
         },
@@ -88,6 +99,7 @@ export function createMemoryService(options = {}) {
             claudeHook.close();
             openCodeHook.close();
             dshHook.close();
+            codeBuddyHook.close();
             turnCoordinator.close();
             repositoryMemorySession.close();
             automaticWriteback.close();

package/lib/memorax-code-backend/dist/shared/windows-cli-invocation.js

@@ -25,6 +25,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}`);
     }
@@ -87,12 +90,18 @@ 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) === "";
+}
 export function resolveWindowsNpmInvocation(args, env, options = {}) {
     const platform = options.platform ?? process.platform;
     if (platform !== "win32")

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

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { loadMemoraxCodeConfig } from "../config/memorax-code.js";
 import { isTraceClient } from "./context.js";
 export const TRACE_CLIENTS = ["codex", "claude", "dsh", "opencode"];
+export const TRACE_RUNTIME_CLIENTS = [...TRACE_CLIENTS, "codebuddy"];
 export const CODEX_TRACE_DEFAULT_CONFIG = {
     enabled: true,
     captureContent: true,
@@ -32,17 +33,22 @@ export const OPENCODE_TRACE_DEFAULT_CONFIG = {
     maxEventChars: 20_000,
     maxFileBytes: 52_428_800,
 };
+export const CODEBUDDY_TRACE_DEFAULT_CONFIG = {
+    ...OPENCODE_TRACE_DEFAULT_CONFIG,
+};
 const TRACE_DEFAULT_CONFIGS = {
     codex: CODEX_TRACE_DEFAULT_CONFIG,
     claude: CLAUDE_TRACE_DEFAULT_CONFIG,
     dsh: DSH_TRACE_DEFAULT_CONFIG,
     opencode: OPENCODE_TRACE_DEFAULT_CONFIG,
+    codebuddy: CODEBUDDY_TRACE_DEFAULT_CONFIG,
 };
 const TRACE_ENV_PREFIXES = {
     codex: "MEMORAX_CODE_CODEX_TRACE",
     claude: "MEMORAX_CODE_CLAUDE_TRACE",
     dsh: "MEMORAX_CODE_DSH_TRACE",
     opencode: "MEMORAX_CODE_OPENCODE_TRACE",
+    codebuddy: "MEMORAX_CODE_CODEBUDDY_TRACE",
 };
 export const TRACE_CLEANUP_DEBOUNCE_MS = 60 * 60 * 1000;
 export const TRACE_CURRENT_TURN_TTL_MS = 30 * 60 * 1000;
@@ -62,6 +68,9 @@ export function dshTraceConfigFromEnv(env = process.env, fileConfig) {
 export function openCodeTraceConfigFromEnv(env = process.env, fileConfig) {
     return clientTraceConfigFromEnv("opencode", env, fileConfig);
 }
+export function codeBuddyTraceConfigFromEnv(env = process.env, fileConfig) {
+    return clientTraceConfigFromEnv("codebuddy", env, fileConfig);
+}
 export function clientTraceConfigFromEnv(client, env = process.env, fileConfig) {
     assertTraceClient(client);
     const config = fileConfig ?? loadMemoraxCodeConfig(memoraxCodeHomeForTrace(env), { warn: () => undefined });
@@ -91,6 +100,9 @@ export function dshTracePaths(memoraxCodeHome = memoraxCodeHomeForTrace(process.
 export function openCodeTracePaths(memoraxCodeHome = memoraxCodeHomeForTrace(process.env)) {
     return clientTracePaths("opencode", memoraxCodeHome);
 }
+export function codeBuddyTracePaths(memoraxCodeHome = memoraxCodeHomeForTrace(process.env)) {
+    return clientTracePaths("codebuddy", memoraxCodeHome);
+}
 export function clientTracePaths(client, memoraxCodeHome = memoraxCodeHomeForTrace(process.env)) {
     assertTraceClient(client);
     const root = join(memoraxCodeHome, "debug", "traces", client);

package/lib/memorax-code-backend/dist/trace/context.js

@@ -62,6 +62,26 @@ export function traceContextFromOpenCodeHookBody(body, capturedAt = new Date().t
         capturedAt,
     });
 }
+export function traceContextFromCodeBuddyHookBody(body, capturedAt = new Date().toISOString()) {
+    if (!isRecord(body))
+        return undefined;
+    const sessionId = stringField(body, "session_id") ?? stringField(body, "sessionId");
+    if (!sessionId)
+        return undefined;
+    const cwd = stringField(body, "cwd");
+    return pruneTraceContext({
+        schemaVersion: "1",
+        client: "codebuddy",
+        sessionId,
+        turnId: stringField(body, "turn_id") ?? stringField(body, "turnId"),
+        transcriptPath: stringField(body, "transcript_path") ?? stringField(body, "transcriptPath"),
+        cwd,
+        memoryProject: resolveMemoryProject(cwd),
+        workspaceKind: stringField(body, "workspace_kind") ?? stringField(body, "workspaceKind"),
+        contextOrigin: "codebuddy-hook-body",
+        capturedAt,
+    });
+}
 export function traceContextFromDshTurnStart(body, capturedAt = new Date().toISOString()) {
     return traceContextFromDshBody(body, "dsh-cordis-turn-start", capturedAt);
 }
@@ -129,7 +149,7 @@ function pruneRecord(value) {
     return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
 }
 export function isTraceClient(value) {
-    return value === "codex" || value === "claude" || value === "dsh" || value === "opencode";
+    return value === "codex" || value === "claude" || value === "dsh" || value === "opencode" || value === "codebuddy";
 }
 function traceContextFromDshBody(body, contextOrigin, capturedAt) {
     if (!isRecord(body))

package/lib/memorax-code-backend/dist/trace/store.js

@@ -60,6 +60,9 @@ export async function recordCodexTraceEvent(input) {
 export async function recordClaudeTraceEvent(input) {
     return recordTraceEventForClient("claude", input);
 }
+export async function recordCodeBuddyTraceEvent(input) {
+    return recordTraceEventForClient("codebuddy", input);
+}
 export function traceTurnEventId(traceContext, type) {
     if (!traceContext?.sessionId || !traceContext.turnId)
         return undefined;
@@ -168,6 +171,12 @@ export async function markCurrentCodexTurnOutcome(traceContext, outcome, options
 export async function markCurrentClaudeTurnOutcome(traceContext, outcome, options = {}) {
     return markCurrentTraceTurnOutcome(traceContext, outcome, { ...options, client: "claude" });
 }
+export async function writeCurrentCodeBuddyTurn(traceContext, options = {}) {
+    return writeCurrentTraceTurn(traceContext, { ...options, client: "codebuddy" });
+}
+export async function markCurrentCodeBuddyTurnOutcome(traceContext, outcome, options = {}) {
+    return markCurrentTraceTurnOutcome(traceContext, outcome, { ...options, client: "codebuddy" });
+}
 async function readCurrentTraceTurnRecord(options) {
     const client = options.client;
     if (!isTraceClient(client))
@@ -303,7 +312,9 @@ function buildTraceEvent(input, config, now, eventId) {
         ok: input.ok,
         outcome: input.outcome,
         related_turns: input.relatedTurns?.map(relatedTurnJson),
-        activities: input.activities,
+        activities: input.activities === undefined
+            ? undefined
+            : sanitizeTraceValue(input.activities, config, captureContent),
         usage: input.usage,
         session_turn_index: input.sessionTurnIndex,
         request: input.request === undefined ? undefined : sanitizeTraceValue(input.request, config, captureContent),

package/lib/memorax-code-backend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memorax-code/backend",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "private": true,
   "type": "module",
   "description": "Local memory integration, lifecycle, trace, and diagnostics for MemoraX Code.",

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

@@ -1,6 +1,6 @@
 {
   "name": "memorax-code-claude-adapter",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Memory skill and local hooks for MemoraX Code in Claude Code.",
   "author": {
     "name": "MemoraX Code Maintainers"

package/lib/memorax-code-claude-adapter/hooks/runtime-shell.json

@@ -1,5 +1,5 @@
 {
   "version": 1,
-  "shellVersion": "0.1.8",
+  "shellVersion": "0.1.10",
   "runtimeAbi": 1
 }

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

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

package/lib/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-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-claude-marketplace/plugins/memorax-code-claude-adapter/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorax-code-claude-adapter",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Memory skill and local hooks for MemoraX Code in Claude Code.",
   "author": {
     "name": "MemoraX Code Maintainers"

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

@@ -1,5 +1,5 @@
 {
   "version": 1,
-  "shellVersion": "0.1.8",
+  "shellVersion": "0.1.10",
   "runtimeAbi": 1
 }

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/automatic-update-state.d.mts

@@ -0,0 +1,24 @@
+export type AutomaticUpdateRecord = Readonly<{
+  version: 1;
+  installedVersion: string;
+  nextCheckAt: string;
+}>;
+
+export type AutomaticUpdateState =
+  | Readonly<{ status: "absent" }>
+  | Readonly<{ status: "valid"; record: AutomaticUpdateRecord }>
+  | Readonly<{ status: "invalid"; reason: string }>
+  | Readonly<{ status: "unsupported"; version: number }>;
+
+export const AUTOMATIC_UPDATE_RECORD_VERSION: 1;
+export const AUTOMATIC_UPDATE_CHECK_INTERVAL_MS: number;
+export const AUTOMATIC_UPDATE_RETRY_INTERVAL_MS: number;
+
+export function automaticUpdateStatePath(memoraxCodeHome: string): string;
+export function readAutomaticUpdateState(memoraxCodeHome: string): AutomaticUpdateState;
+export function writeAutomaticUpdateState(options: {
+  memoraxCodeHome: string;
+  nowMs: number;
+  installedVersion: string;
+  retry: boolean;
+}): AutomaticUpdateRecord;

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/automatic-update-state.mjs

@@ -0,0 +1,73 @@
+import { join, resolve } from "node:path";
+import {
+  readJsonRuntimeRecord,
+  writePrivateJsonRecord,
+} from "./runtime-record.mjs";
+
+export const AUTOMATIC_UPDATE_RECORD_VERSION = 1;
+export const AUTOMATIC_UPDATE_CHECK_INTERVAL_MS = 8 * 60 * 60 * 1_000;
+export const AUTOMATIC_UPDATE_RETRY_INTERVAL_MS = 15 * 60 * 1_000;
+
+const RECORD_KEYS = new Set(["version", "installedVersion", "nextCheckAt"]);
+
+export function automaticUpdateStatePath(memoraxCodeHome) {
+  return join(resolve(memoraxCodeHome), "runtime", "install", "automatic-update.json");
+}
+
+export function readAutomaticUpdateState(memoraxCodeHome) {
+  const state = readJsonRuntimeRecord(automaticUpdateStatePath(memoraxCodeHome));
+  if (state.status !== "present") return state;
+  const value = state.value;
+  if (value.version !== AUTOMATIC_UPDATE_RECORD_VERSION) {
+    return Number.isSafeInteger(value.version) && value.version > 0
+      ? { status: "unsupported", version: value.version }
+      : { status: "invalid", reason: "invalid_version" };
+  }
+  if (Object.keys(value).length !== RECORD_KEYS.size
+    || Object.keys(value).some((key) => !RECORD_KEYS.has(key))) {
+    return { status: "invalid", reason: "unknown_or_missing_fields" };
+  }
+  const installedVersion = nonEmptyString(value.installedVersion);
+  const nextCheckAt = timestamp(value.nextCheckAt);
+  if (!installedVersion || !nextCheckAt) {
+    return { status: "invalid", reason: "invalid_fields" };
+  }
+  return {
+    status: "valid",
+    record: {
+      version: AUTOMATIC_UPDATE_RECORD_VERSION,
+      installedVersion,
+      nextCheckAt,
+    },
+  };
+}
+
+export function writeAutomaticUpdateState({ memoraxCodeHome, nowMs, installedVersion, retry }) {
+  const timestampMs = Number(nowMs);
+  const version = nonEmptyString(installedVersion);
+  if (!Number.isFinite(timestampMs) || !version) {
+    throw new TypeError("automatic update state requires a timestamp and installed version");
+  }
+  const record = {
+    version: AUTOMATIC_UPDATE_RECORD_VERSION,
+    installedVersion: version,
+    nextCheckAt: new Date(
+      timestampMs + (retry ? AUTOMATIC_UPDATE_RETRY_INTERVAL_MS : AUTOMATIC_UPDATE_CHECK_INTERVAL_MS),
+    ).toISOString(),
+  };
+  writePrivateJsonRecord(automaticUpdateStatePath(memoraxCodeHome), record, {
+    durableBoundary: memoraxCodeHome,
+  });
+  return record;
+}
+
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function timestamp(value) {
+  const candidate = nonEmptyString(value);
+  return candidate && Number.isFinite(Date.parse(candidate))
+    ? new Date(Date.parse(candidate)).toISOString()
+    : undefined;
+}

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/clients/codebuddy-command.mjs

@@ -0,0 +1,82 @@
+import { accessSync, constants, existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, win32 } from "node:path";
+
+const APP_NAMES = ["WorkBuddy.app", "CodeBuddy.app"];
+const BUNDLED_SEGMENTS = ["Contents", "Resources", "app.asar.unpacked", "cli", "bin", "codebuddy"];
+const WINDOWS_SEGMENTS = [
+  ["resources", "app.asar.unpacked", "cli", "bin", "codebuddy"],
+  ["resources", "app.asar.unpacked", "cli", "bin", "codebuddy.exe"],
+];
+
+/**
+ * Resolve the CodeBuddy executable from the environment, installed adapter
+ * metadata, or the WorkBuddy/CodeBuddy application bundle.  Hooks are often
+ * launched by a GUI process and therefore cannot rely on the user's shell
+ * PATH or on npm's environment setup.
+ */
+export function resolveHookCodeBuddyCommand({
+  env = process.env,
+  pluginRoot,
+  homeDir = homedir(),
+  platform = process.platform,
+  pathExists = commandPathExists,
+} = {}) {
+  const configured = stringValue(env.MEMORAX_CODE_CODEBUDDY_COMMAND)
+    ?? stringValue(env.CODEBUDDY_CLI_PATH)
+    ?? stringValue(env.WORKBUDDY_CODEBUDDY_PATH);
+  if (configured) return configured;
+
+  const metadataCommand = readMetadataCommand(stringValue(pluginRoot) ?? stringValue(env.CODEBUDDY_PLUGIN_ROOT));
+  if (metadataCommand && pathExists(metadataCommand, platform)) return metadataCommand;
+
+  if (platform === "darwin") {
+    for (const root of [join(homeDir, "Applications"), "/Applications"]) {
+      for (const appName of APP_NAMES) {
+        const command = join(root, appName, ...BUNDLED_SEGMENTS);
+        if (pathExists(command, platform)) return command;
+      }
+    }
+  }
+  if (platform === "win32") {
+    for (const root of [
+      env.LOCALAPPDATA && win32.join(env.LOCALAPPDATA, "Programs", "WorkBuddy"),
+      env.LOCALAPPDATA && win32.join(env.LOCALAPPDATA, "Programs", "CodeBuddy"),
+      env.LOCALAPPDATA && win32.join(env.LOCALAPPDATA, "WorkBuddy"),
+      env.LOCALAPPDATA && win32.join(env.LOCALAPPDATA, "CodeBuddy"),
+      env.ProgramFiles && win32.join(env.ProgramFiles, "WorkBuddy"),
+      env.ProgramFiles && win32.join(env.ProgramFiles, "CodeBuddy"),
+    ].filter(Boolean)) {
+      for (const segments of WINDOWS_SEGMENTS) {
+        const command = win32.join(root, ...segments);
+        if (pathExists(command, platform)) return command;
+      }
+    }
+  }
+  return "codebuddy";
+}
+
+function readMetadataCommand(pluginRoot) {
+  if (!pluginRoot) return undefined;
+  try {
+    const metadata = JSON.parse(readFileSync(join(pluginRoot, ".memorax-code-package.json"), "utf8"));
+    return stringValue(metadata?.codeBuddyCommand);
+  } catch {
+    return undefined;
+  }
+}
+
+function commandPathExists(command, platform) {
+  if (!command.includes("/") && !command.includes("\\")) return true;
+  if (!existsSync(command)) return false;
+  try {
+    accessSync(command, platform === "win32" ? constants.F_OK : constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/config-utils.d.mts

@@ -13,6 +13,8 @@ export function readJsonFile(path: string): any;
 export function readJsonValue(path: string): any;
 export function readStdinJson(): Promise<any>;
 export function injectClientHookInput(input: Record<string, unknown>): void;
+export function injectClientHookPluginRoot(pluginRoot: string): void;
+export function readClientHookPluginRoot(): string | undefined;
 export function sha256(value: string | NodeJS.ArrayBufferView): string;
 export function stringOption(value: unknown): string | undefined;
 export function atomicWriteJson(path: string, value: unknown): void;

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/config-utils.mjs

@@ -24,6 +24,7 @@ const JSON_FILE_LOCK_RETRY_MS = 10;
 const PROCESS_START_TOLERANCE_MS = 5000;
 const LOCK_SLEEP_BUFFER = new Int32Array(new SharedArrayBuffer(4));
 const HOOK_INPUT_SYMBOL = Symbol.for("memorax-code.client-hook.input.v1");
+const HOOK_PLUGIN_ROOT_SYMBOL = Symbol.for("memorax-code.client-hook.plugin-root.v1");
 
 export function readAdapterState(path) {
   const state = readJsonFile(path);
@@ -64,6 +65,16 @@ export function injectClientHookInput(input) {
   globalThis[HOOK_INPUT_SYMBOL] = input;
 }
 
+export function injectClientHookPluginRoot(pluginRoot) {
+  const root = stringOption(pluginRoot);
+  if (!root) throw new TypeError("client Hook plugin root must be a non-empty string");
+  globalThis[HOOK_PLUGIN_ROOT_SYMBOL] = root;
+}
+
+export function readClientHookPluginRoot() {
+  return stringOption(globalThis[HOOK_PLUGIN_ROOT_SYMBOL]);
+}
+
 export function sha256(value) {
   return createHash("sha256").update(value).digest("hex");
 }

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/hooks/client-hook-launcher.mjs

@@ -5,6 +5,7 @@ import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import {
   injectClientHookInput,
+  injectClientHookPluginRoot,
   readStdinJson,
   stringOption,
   withJsonFileLock,
@@ -47,6 +48,8 @@ export async function runClientHookLauncher({
     });
     if (!selection) return;
     injectClientHookInput(input);
+    const originalPluginRoot = stringOption(pluginRoot);
+    if (originalPluginRoot) injectClientHookPluginRoot(originalPluginRoot);
     await import(pathToFileURL(selection.modulePath).href);
   } catch (error) {
     if (process.env[debugEnv] === "1") {