@memorax/memorax-code 0.1.8 → 0.1.10

package/lib/memorax-code-codebuddy-adapter/src/runtime-observation.mjs

@@ -0,0 +1,65 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+export function codeBuddyRuntimeObservationPath(memoraxCodeHome) {
+  return join(memoraxCodeHome, "adapters", "codebuddy", "runtime-observed.json");
+}
+
+export async function writeCodeBuddyRuntimeObservation({
+  memoraxCodeHome,
+  codeBuddyHome,
+  pluginRoot,
+}) {
+  const pluginVersion = await readPluginVersion(pluginRoot);
+  const path = codeBuddyRuntimeObservationPath(memoraxCodeHome);
+  const record = {
+    version: 1,
+    pluginVersion,
+    codeBuddyHome,
+    observedAt: new Date().toISOString(),
+  };
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  const temp = `${path}.tmp-${process.pid}-${Date.now()}`;
+  await writeFile(temp, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600 });
+  await rename(temp, path);
+  return record;
+}
+
+export async function readCodeBuddyRuntimeObservation(memoraxCodeHome) {
+  try {
+    const value = JSON.parse(await readFile(codeBuddyRuntimeObservationPath(memoraxCodeHome), "utf8"));
+    if (!isRecord(value) || !hasExactKeys(value, ["codeBuddyHome", "observedAt", "pluginVersion", "version"])) {
+      return undefined;
+    }
+    if (value.version !== 1
+      || !stringValue(value.pluginVersion)
+      || !stringValue(value.codeBuddyHome)
+      || !validTimestamp(value.observedAt)) return undefined;
+    return value;
+  } catch {
+    return undefined;
+  }
+}
+
+async function readPluginVersion(pluginRoot) {
+  const manifest = JSON.parse(await readFile(join(pluginRoot, ".codebuddy-plugin", "plugin.json"), "utf8"));
+  const version = stringValue(manifest?.version);
+  if (!version) throw new Error("CodeBuddy plugin manifest has no version");
+  return version;
+}
+
+function isRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value);
+}
+
+function hasExactKeys(value, expected) {
+  return Object.keys(value).sort().join("\n") === [...expected].sort().join("\n");
+}
+
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function validTimestamp(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}

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

@@ -1,6 +1,6 @@
 {
   "name": "memorax-code-codex-adapter",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Codex adapter, memory skill, and local hooks for MemoraX Code.",
   "author": {
     "name": "MemoraX AI"

package/lib/memorax-code-codex-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-codex-adapter/package.json

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

package/lib/memorax-code-codex-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,
@@ -56,7 +57,9 @@ async function reconcileAdapter(homes, backendUrl) {
 }
 
 function pluginRoot() {
-  return stringValue(process.env.PLUGIN_ROOT) ?? dirname(dirname(fileURLToPath(import.meta.url)));
+  return stringValue(process.env.PLUGIN_ROOT)
+    ?? readClientHookPluginRoot()
+    ?? dirname(dirname(fileURLToPath(import.meta.url)));
 }
 
 function hookHomes(input = {}) {

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

@@ -1,6 +1,6 @@
 {
   "name": "@memorax-code/dsh-memorax-code",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "private": true,
   "type": "module",
   "description": "DeepSeek Harness native memory adapter for MemoraX Code.",
@@ -44,6 +44,7 @@
     "src/runtime-state.mjs",
     "memorax-code-adapter-common/src/backend-connection.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/memory-skill-reminder-policy.mjs",
     "memorax-code-adapter-common/src/repo-memory/repo-memory-auto-build.mjs",

package/lib/memorax-code-dsh-adapter/src/profile-lifecycle.mjs

@@ -100,6 +100,7 @@ const PROFILE_BUNDLE_FILES = Object.freeze([
   "src/runtime-state.mjs",
   "memorax-code-adapter-common/src/backend-connection.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/memory-skill-reminder-policy.mjs",
   "memorax-code-adapter-common/src/repo-memory/repo-memory-auto-build.mjs",

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

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

package/lib/npm-invocation.mjs

@@ -1,12 +1,26 @@
+import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
+import { homedir } from "node:os";
 import path from "node:path";
 
 export function resolveNpmInvocation(npmArgs, options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform !== "win32") return { command: "npm", args: npmArgs };
+  const nodePath = options.nodePath ?? process.execPath;
+  const npmCli = resolveNpmExecPath(options);
+  if (npmCli) return { command: nodePath, args: [npmCli, ...npmArgs] };
+  throw new Error(
+    "npm CLI JavaScript entrypoint was not found; set MEMORAX_CODE_NPM_EXEC_PATH, "
+    + "npm_execpath, or NPM_CLI_JS before running memorax-code update",
+  );
+}
+
+export function resolveNpmExecPath(options = {}) {
   const env = options.env ?? process.env;
   const platform = options.platform ?? process.platform;
+  if (platform !== "win32") return undefined;
   const nodePath = options.nodePath ?? process.execPath;
   const fileExists = options.existsSync ?? existsSync;
-  if (platform !== "win32") return { command: "npm", args: npmArgs };
   const pathApi = path.win32;
   const candidates = [
     env.MEMORAX_CODE_NPM_EXEC_PATH,
@@ -21,11 +35,40 @@ export function resolveNpmInvocation(npmArgs, options = {}) {
       "bin",
       "npm-cli.js",
     ),
-  ].filter((candidate) => typeof candidate === "string" && /\.(?:cjs|js|mjs)$/i.test(candidate));
-  const npmCli = candidates.find((candidate) => fileExists(candidate));
-  if (npmCli) return { command: nodePath, args: [npmCli, ...npmArgs] };
-  throw new Error(
-    "npm CLI JavaScript entrypoint was not found; set MEMORAX_CODE_NPM_EXEC_PATH, "
-    + "npm_execpath, or NPM_CLI_JS before running memorax-code update",
-  );
+  ].filter((candidate) => (
+    typeof candidate === "string"
+    && pathApi.isAbsolute(candidate)
+    && /\.(?:cjs|js|mjs)$/i.test(candidate)
+  ));
+  return candidates.find((candidate) => fileExists(candidate));
+}
+
+export function npmCommandCwd(env = process.env) {
+  for (const candidate of [env.HOME, homedir(), "/"]) {
+    if (candidate && existsSync(candidate)) return candidate;
+  }
+  return "/";
+}
+
+export async function runNpmCommand(npmArgs, options = {}) {
+  const env = options.env ?? process.env;
+  const invocation = resolveNpmInvocation(npmArgs, options);
+  const cwd = options.cwd ?? npmCommandCwd(env);
+  const child = (options.spawnProcess ?? spawn)(invocation.command, invocation.args, {
+    cwd,
+    env: { ...env, PWD: cwd },
+    stdio: options.stdio ?? "inherit",
+    windowsHide: options.windowsHide ?? false,
+  });
+  return await waitForChildProcess(child);
+}
+
+export async function waitForChildProcess(child) {
+  return await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("close", (code, signal) => resolve({
+      exitCode: signal ? 1 : (code ?? 1),
+      signal,
+    }));
+  });
 }

package/lib/resolve-codebuddy-command.mjs

@@ -0,0 +1,112 @@
+import { homedir } from "node:os";
+import { delimiter, join, win32 } from "node:path";
+import {
+  commandOnPath,
+  isExecutableCommand,
+} from "./vscode-extension-command.mjs";
+
+const WORKBUDDY_APP_NAMES = ["WorkBuddy.app", "CodeBuddy.app"];
+const WORKBUDDY_BUNDLED_SEGMENTS = [
+  "Contents",
+  "Resources",
+  "app.asar.unpacked",
+  "cli",
+  "bin",
+  "codebuddy",
+];
+const WINDOWS_WORKBUDDY_SEGMENTS = [
+  ["resources", "app.asar.unpacked", "cli", "bin", "codebuddy"],
+  ["resources", "app.asar.unpacked", "cli", "bin", "codebuddy.exe"],
+];
+
+export function resolveCodeBuddyCommand({
+  env = process.env,
+  homeDir = homedir(),
+  platform = process.platform,
+  applicationRoots = [join(homeDir, "Applications"), "/Applications"],
+  windowsRoots = defaultWindowsRoots(env, homeDir),
+  pathExists = isExecutableCommand,
+} = {}) {
+  const override = nonEmpty(env.MEMORAX_CODE_CODEBUDDY_COMMAND)
+    ?? nonEmpty(env.CODEBUDDY_CLI_PATH)
+    ?? nonEmpty(env.WORKBUDDY_CODEBUDDY_PATH);
+  if (override) return { command: override, source: "configured" };
+
+  if (commandOnPath("codebuddy", env.PATH, platform, env.PATHEXT)) {
+    return { command: findCommandOnPath("codebuddy", env.PATH, platform, env.PATHEXT), source: "path" };
+  }
+
+  if (platform === "darwin") {
+    for (const root of applicationRoots) {
+      for (const appName of WORKBUDDY_APP_NAMES) {
+        const command = join(root, appName, ...WORKBUDDY_BUNDLED_SEGMENTS);
+        if (pathExists(command, platform)) return { command, source: "app-bundled" };
+      }
+    }
+  }
+
+  if (platform === "win32") {
+    for (const root of windowsRoots) {
+      for (const segments of WINDOWS_WORKBUDDY_SEGMENTS) {
+        const command = win32.join(root, ...segments);
+        if (pathExists(command, platform)) return { command, source: "app-bundled" };
+      }
+    }
+  }
+
+  return { command: "codebuddy", source: "unavailable" };
+}
+
+function findCommandOnPath(command, pathValue, platform, pathExtValue) {
+  const extensions = platform === "win32"
+    ? String(pathExtValue ?? ".EXE;.CMD;.BAT;.COM").split(";")
+    : [""];
+  const pathDelimiter = platform === "win32" ? ";" : delimiter;
+  const pathJoin = platform === "win32" ? win32.join : join;
+  for (const root of String(pathValue ?? "").split(pathDelimiter)) {
+    if (!root) continue;
+    for (const extension of extensions) {
+      const candidate = pathJoin(root, `${command}${extension}`);
+      if (isExecutableCommand(candidate, platform)) return candidate;
+    }
+  }
+  return platform === "win32" ? "codebuddy.exe" : "codebuddy";
+}
+
+export function ensureCodeBuddyCommandEnv(options = {}) {
+  const env = options.env ?? process.env;
+  const resolved = resolveCodeBuddyCommand({ ...options, env });
+  if (resolved.source !== "unavailable") env.MEMORAX_CODE_CODEBUDDY_COMMAND = resolved.command;
+  return resolved;
+}
+
+export function defaultCodeBuddyHome(env = process.env, homeDir = homedir(), platform = process.platform) {
+  return nonEmpty(env.CODEBUDDY_HOME)
+    ?? nonEmpty(env.WORKBUDDY_HOME)
+    ?? (platform === "win32" ? win32.join(homeDir, ".codebuddy") : join(homeDir, ".workbuddy"));
+}
+
+function defaultWindowsRoots(env, homeDir) {
+  const roots = [];
+  const localAppData = nonEmpty(env.LOCALAPPDATA) ?? join(homeDir, "AppData", "Local");
+  const programFiles = nonEmpty(env.ProgramFiles) ?? "C:\\Program Files";
+  const programFilesX86 = nonEmpty(env["ProgramFiles(x86)"]) ?? "C:\\Program Files (x86)";
+  for (const root of [
+    win32.join(localAppData, "Programs", "WorkBuddy"),
+    win32.join(localAppData, "Programs", "CodeBuddy"),
+    win32.join(localAppData, "WorkBuddy"),
+    win32.join(localAppData, "CodeBuddy"),
+    win32.join(programFiles, "WorkBuddy"),
+    win32.join(programFiles, "CodeBuddy"),
+    win32.join(programFilesX86, "WorkBuddy"),
+    win32.join(programFilesX86, "CodeBuddy"),
+  ]) {
+    if (!roots.includes(root)) roots.push(root);
+  }
+  return roots;
+}
+
+function nonEmpty(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || undefined;
+}

package/lib/run-entrypoint.mjs

@@ -1,8 +1,11 @@
-import { delimiter, dirname, join } from "node:path";
+import { readFileSync } from "node:fs";
+import { delimiter, dirname, join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { unsupportedNodeVersionMessage } from "./node-version.mjs";
+import { resolveNpmExecPath } from "./npm-invocation.mjs";
 import { ensureClaudeCommandEnv } from "./resolve-claude-command.mjs";
 import { ensureCodexCommandEnv } from "./resolve-codex-command.mjs";
+import { ensureCodeBuddyCommandEnv } from "./resolve-codebuddy-command.mjs";
 
 const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
 
@@ -41,13 +44,27 @@ export function ensureInstallWatchdogEnv(root = packageRoot) {
   }
 }
 
+export function ensureNpmPackageRuntimeEnv(root = packageRoot, options = {}) {
+  const env = options.env ?? process.env;
+  const resolvedRoot = resolve(root);
+  const metadata = JSON.parse(readFileSync(join(resolvedRoot, "package.json"), "utf8"));
+  const version = typeof metadata.version === "string" ? metadata.version.trim() : "";
+  if (!version) throw new Error("MemoraX Code package version is missing");
+  env.MEMORAX_CODE_NPM_PACKAGE_ROOT = resolvedRoot;
+  env.MEMORAX_CODE_NPM_PACKAGE_VERSION = version;
+  const npmExecPath = resolveNpmExecPath({ ...options, env });
+  if (npmExecPath) env.MEMORAX_CODE_NPM_EXEC_PATH = npmExecPath;
+}
+
 export async function runBackendEntrypoint(relativeEntrypoint) {
   if (!ensureSupportedNodeRuntime()) return;
   ensureCodexCommandEnv();
   ensureClaudeCommandEnv();
+  ensureCodeBuddyCommandEnv();
   ensureBundledSkillEnv();
   ensureClaudeMarketplaceEnv();
   ensureInstallWatchdogEnv();
+  ensureNpmPackageRuntimeEnv();
   const entrypoint = join(packageRoot, "lib", "memorax-code-backend", "dist", relativeEntrypoint);
   const previousArgv1 = process.argv[1];
   process.argv[1] = entrypoint;
@@ -80,6 +97,13 @@ export async function runOpenCodeAdapterCli() {
   await import(pathToFileURL(entrypoint).href);
 }
 
+export async function runCodeBuddyAdapterCli() {
+  if (!ensureSupportedNodeRuntime()) return;
+  ensureCodeBuddyCommandEnv();
+  const entrypoint = join(packageRoot, "lib", "memorax-code-codebuddy-adapter", "src", "cli.mjs");
+  await import(pathToFileURL(entrypoint).href);
+}
+
 function ensureSupportedNodeRuntime() {
   const message = unsupportedNodeVersionMessage();
   if (!message) return true;

package/lib/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}`);
   }
@@ -92,9 +95,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/windows-user-path.mjs

@@ -0,0 +1,218 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { resolveNpmInvocation } from "./npm-invocation.mjs";
+
+const WINDOWS_USER_PATH_SCRIPT = String.raw`
+$ErrorActionPreference = "Stop"
+$globalBin = $env:MEMORAX_CODE_WINDOWS_NPM_GLOBAL_BIN
+
+function Normalize-PathEntry([string]$Value) {
+    if ([string]::IsNullOrWhiteSpace($Value)) { return "" }
+    return [Environment]::ExpandEnvironmentVariables(
+        $Value.Trim().Trim('"')
+    ).TrimEnd('\')
+}
+
+$normalizedGlobalBin = Normalize-PathEntry $globalBin
+$changed = $false
+$completed = $false
+
+for ($attempt = 0; $attempt -lt 3; $attempt++) {
+    $userPath = [Environment]::GetEnvironmentVariable("Path", "User")
+    $entries = @($userPath -split ";" | Where-Object {
+        -not [string]::IsNullOrWhiteSpace($_)
+    })
+    $present = @($entries | Where-Object {
+        (Normalize-PathEntry $_) -ieq $normalizedGlobalBin
+    }).Count -gt 0
+
+    if ($present) {
+        $completed = $true
+        break
+    }
+
+    $separator = if ([string]::IsNullOrWhiteSpace($userPath) -or $userPath.TrimEnd().EndsWith(";")) { "" } else { ";" }
+    $updatedPath = "$userPath$separator$globalBin"
+    if ($updatedPath.Length -ge 32767) {
+        throw "The updated user PATH would exceed the Windows environment limit."
+    }
+
+    $latestUserPath = [Environment]::GetEnvironmentVariable("Path", "User")
+    if (-not [string]::Equals([string]$latestUserPath, [string]$userPath, [StringComparison]::Ordinal)) {
+        continue
+    }
+
+    [Environment]::SetEnvironmentVariable("Path", $updatedPath, "User")
+    $changed = $true
+    $writtenUserPath = [Environment]::GetEnvironmentVariable("Path", "User")
+    if ([string]::Equals([string]$writtenUserPath, [string]$updatedPath, [StringComparison]::Ordinal)) {
+        $completed = $true
+        break
+    }
+}
+
+if (-not $completed) {
+    throw "The Windows user PATH changed concurrently; retry setup."
+}
+
+[Console]::Out.Write((@{ changed = $changed } | ConvertTo-Json -Compress))
+`;
+
+export function ensureWindowsNpmGlobalPath(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  if (platform !== "win32") return result("skipped", "unsupported_platform");
+
+  let globalBin;
+  try {
+    globalBin = (options.resolveGlobalPrefix ?? resolveWindowsNpmGlobalPrefix)({
+      ...options,
+      env,
+      platform,
+    });
+  } catch {
+    return result("warning", "npm_prefix_unavailable");
+  }
+  if (typeof globalBin !== "string"
+    || globalBin.includes(";")
+    || !path.win32.isAbsolute(globalBin.trim())) {
+    return result("warning", "npm_prefix_unavailable");
+  }
+  globalBin = path.win32.normalize(globalBin.trim());
+
+  const fileExists = options.existsSync ?? existsSync;
+  const requiredShims = ["memorax-code.cmd", "memorax-cli.cmd"];
+  if (!requiredShims.every((name) => fileExists(path.win32.join(globalBin, name)))) {
+    return result("warning", "global_shims_missing");
+  }
+
+  const pathKey = windowsPathKey(env);
+  const currentPath = typeof env[pathKey] === "string" ? env[pathKey] : "";
+  const processPathChanged = !windowsPathContains(currentPath, globalBin, env);
+  if (processPathChanged) {
+    env[pathKey] = currentPath
+      ? `${currentPath}${currentPath.trimEnd().endsWith(";") ? "" : ";"}${globalBin}`
+      : globalBin;
+  }
+
+  let userPathChanged = false;
+  try {
+    const update = (options.updateUserPath ?? updateWindowsUserPath)(globalBin, {
+      ...options,
+      env,
+      platform,
+    });
+    if (typeof update?.changed !== "boolean") throw new Error("invalid user PATH update result");
+    userPathChanged = update.changed;
+  } catch {
+    return result("warning", "user_path_update_failed", {
+      processPathChanged,
+    });
+  }
+
+  const changed = processPathChanged || userPathChanged;
+  return result(changed ? "updated" : "unchanged", undefined, {
+    processPathChanged,
+    userPathChanged,
+    restartRecommended: changed,
+  });
+}
+
+export function resolveWindowsNpmGlobalPrefix(options = {}) {
+  const env = options.env ?? process.env;
+  const invocation = resolveNpmInvocation(["prefix", "-g"], options);
+  const run = options.spawnSync ?? spawnSync;
+  const resolved = run(invocation.command, invocation.args, {
+    encoding: "utf8",
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 10_000,
+    windowsHide: true,
+  });
+  if (resolved.error || resolved.signal || resolved.status !== 0) {
+    throw new Error("npm global prefix command failed");
+  }
+  const lines = String(resolved.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const prefix = lines.at(-1);
+  if (!prefix || !path.win32.isAbsolute(prefix)) throw new Error("npm global prefix is invalid");
+  return prefix;
+}
+
+export function updateWindowsUserPath(globalBin, options = {}) {
+  const env = options.env ?? process.env;
+  const run = options.spawnSync ?? spawnSync;
+  const powerShell = windowsPowerShellCommand(env, options.existsSync ?? existsSync);
+  const encodedCommand = Buffer.from(WINDOWS_USER_PATH_SCRIPT, "utf16le").toString("base64");
+  const updated = run(powerShell, [
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-EncodedCommand",
+    encodedCommand,
+  ], {
+    encoding: "utf8",
+    env: { ...env, MEMORAX_CODE_WINDOWS_NPM_GLOBAL_BIN: globalBin },
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 10_000,
+    windowsHide: true,
+  });
+  if (updated.error || updated.signal || updated.status !== 0) {
+    throw new Error("Windows user PATH update failed");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(String(updated.stdout ?? "").trim());
+  } catch {
+    throw new Error("Windows user PATH update returned invalid output");
+  }
+  if (typeof parsed?.changed !== "boolean") {
+    throw new Error("Windows user PATH update returned an invalid result");
+  }
+  return { changed: parsed.changed };
+}
+
+function windowsPathKey(env) {
+  return Object.keys(env).find((key) => key.toLowerCase() === "path") ?? "Path";
+}
+
+function windowsPathContains(pathValue, expected, env) {
+  const normalizedExpected = normalizeWindowsPathEntry(expected, env);
+  return String(pathValue ?? "").split(";").some((entry) => (
+    normalizeWindowsPathEntry(entry, env) === normalizedExpected
+  ));
+}
+
+function normalizeWindowsPathEntry(value, env) {
+  const expanded = String(value ?? "")
+    .trim()
+    .replace(/^"|"$/g, "")
+    .replace(/%([^%]+)%/g, (match, name) => environmentValue(env, name) ?? match);
+  if (!expanded) return "";
+  return path.win32.normalize(expanded).replace(/[\\/]+$/, "").toLowerCase();
+}
+
+function environmentValue(env, name) {
+  const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+  return key === undefined ? undefined : env[key];
+}
+
+function windowsPowerShellCommand(env, fileExists) {
+  const systemRoot = environmentValue(env, "SystemRoot") ?? environmentValue(env, "WINDIR");
+  if (systemRoot) {
+    const candidate = path.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+    if (fileExists(candidate)) return candidate;
+  }
+  return "powershell.exe";
+}
+
+function result(status, reason, overrides = {}) {
+  return {
+    status,
+    ...(reason ? { reason } : {}),
+    processPathChanged: false,
+    userPathChanged: false,
+    restartRecommended: false,
+    ...overrides,
+  };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@memorax/memorax-code",
-  "version": "0.1.8",
-  "description": "Persistent coding memory for Codex, Claude Code, DeepSeek Harness, and OpenCode.",
+  "version": "0.1.10",
+  "description": "Persistent coding memory for Codex, Claude Code, CodeBuddy/WorkBuddy, DeepSeek Harness, and OpenCode.",
   "license": "MIT",
   "type": "module",
   "homepage": "https://github.com/memorax-ai/memorax-code#readme",
@@ -18,6 +18,7 @@
     "deepseek-harness",
     "dsh",
     "opencode",
+    "codebuddy",
     "memory",
     "memorax"
   ],
@@ -27,7 +28,8 @@
     "memorax-code-backend": "bin/memorax-code-backend.mjs",
     "memorax-code-claude": "bin/memorax-code-claude.mjs",
     "memorax-code-codex": "bin/memorax-code-codex.mjs",
-    "memorax-code-opencode": "bin/memorax-code-opencode.mjs"
+    "memorax-code-opencode": "bin/memorax-code-opencode.mjs",
+    "memorax-code-codebuddy": "bin/memorax-code-codebuddy.mjs"
   },
   "files": [
     "bin",