@memorax/memorax-code 0.1.9 → 0.1.11

package/lib/memorax-code-codebuddy-adapter/src/hook-manifest.mjs

@@ -0,0 +1,47 @@
+import { readFile, stat, writeFile } from "node:fs/promises";
+import { join, win32 } from "node:path";
+
+const REQUIRED_EVENTS = ["SessionStart", "UserPromptSubmit", "Stop"];
+const PORTABLE_COMMAND = 'node "${CODEBUDDY_PLUGIN_ROOT}/hooks/runtime-hook.mjs" turn';
+
+export function codeBuddyHookCommand(pluginRoot, platform = process.platform) {
+  if (platform !== "win32") return PORTABLE_COMMAND;
+  return `node "${win32.join(pluginRoot, "hooks", "runtime-hook.mjs").replaceAll("\\", "/")}" turn`;
+}
+
+export async function materializeCodeBuddyHookManifest(pluginRoot, platform = process.platform) {
+  if (platform !== "win32") return;
+  const path = join(pluginRoot, "hooks", "hooks.json");
+  const manifest = JSON.parse(await readFile(path, "utf8"));
+  const command = codeBuddyHookCommand(pluginRoot, platform);
+  for (const event of REQUIRED_EVENTS) {
+    const hooks = commandHooks(manifest, event);
+    if (hooks.length === 0) throw new Error(`CodeBuddy Hook manifest is missing ${event}`);
+    for (const hook of hooks) hook.command = command;
+  }
+  await writeFile(path, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+}
+
+export async function codeBuddyHookManifestConfigured(pluginRoot, platform = process.platform) {
+  try {
+    await stat(join(pluginRoot, "hooks", "runtime-hook.mjs"));
+    const manifest = JSON.parse(await readFile(join(pluginRoot, "hooks", "hooks.json"), "utf8"));
+    const expected = codeBuddyHookCommand(pluginRoot, platform);
+    return REQUIRED_EVENTS.every((event) => {
+      const hooks = commandHooks(manifest, event);
+      return hooks.length > 0 && hooks.every((hook) => hook.command === expected);
+    });
+  } catch {
+    return false;
+  }
+}
+
+function commandHooks(manifest, event) {
+  const matchers = manifest?.hooks?.[event];
+  if (!Array.isArray(matchers)) return [];
+  return matchers.flatMap((matcher) => (
+    Array.isArray(matcher?.hooks)
+      ? matcher.hooks.filter((hook) => hook?.type === "command" && typeof hook.command === "string")
+      : []
+  ));
+}

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.9",
+  "version": "0.1.11",
   "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.9",
+  "shellVersion": "0.1.11",
   "runtimeAbi": 1
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "@memorax-code/codex-adapter",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "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.9",
+  "version": "0.1.11",
   "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.9",
+  "version": "0.1.11",
   "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,123 @@
+import { existsSync } from "node:fs";
+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,
+  pathExists = existsSync,
+) {
+  const configured = nonEmpty(env.CODEBUDDY_HOME) ?? nonEmpty(env.WORKBUDDY_HOME);
+  if (configured) return configured;
+  if (platform !== "win32") return join(homeDir, ".workbuddy");
+  const workBuddyHome = win32.join(homeDir, ".workbuddy");
+  const legacyCodeBuddyHome = win32.join(homeDir, ".codebuddy");
+  return pathExists(workBuddyHome) || !pathExists(legacyCodeBuddyHome)
+    ? workBuddyHome
+    : legacyCodeBuddyHome;
+}
+
+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) === "";
+}