@memorax/memorax-code 0.1.0

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/memorax-code-adapter-common/src/runtime-record.mjs

@@ -0,0 +1,152 @@
+import { randomUUID } from "node:crypto";
+import {
+  chmodSync,
+  closeSync,
+  fsyncSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+
+export class RuntimeRecordError extends Error {
+  constructor({ name, path, state, codePrefix, recovery }) {
+    const detail = state.status === "unsupported"
+      ? `uses unsupported version ${state.version}`
+      : state.status === "invalid"
+        ? `is invalid (${state.reason})`
+        : "is missing";
+    super(`${name} ${detail}: ${path}${recovery ? `; ${recovery}` : ""}`);
+    this.name = "RuntimeRecordError";
+    this.code = `${codePrefix}_${state.status.toUpperCase()}`;
+    this.recordStatus = state.status;
+    this.recordPath = path;
+    if (state.status === "unsupported") this.version = state.version;
+    if (state.status === "invalid") this.reason = state.reason;
+  }
+}
+
+export function readJsonRuntimeRecord(path) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") return { status: "absent" };
+    return { status: "invalid", reason: "unreadable" };
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return { status: "invalid", reason: "malformed_json" };
+  }
+  if (!isRecord(value)) return { status: "invalid", reason: "invalid_record" };
+  return { status: "present", value };
+}
+
+export function writePrivateJsonRecord(path, value, options) {
+  const directoryPath = dirname(path);
+  ensurePrivateDirectory(directoryPath, {
+    durableBoundary: options?.durableBoundary,
+  });
+  const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  let descriptor;
+  try {
+    descriptor = openSync(temporaryPath, "wx", 0o600);
+    writeFileSync(descriptor, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    fsyncSync(descriptor);
+    closeSync(descriptor);
+    descriptor = undefined;
+    renameSync(temporaryPath, path);
+  } catch (error) {
+    if (descriptor !== undefined) {
+      try {
+        closeSync(descriptor);
+      } catch {
+        // Best-effort cleanup after an incomplete write.
+      }
+    }
+    try {
+      rmSync(temporaryPath, { force: true });
+    } catch {
+      // Preserve the original write failure.
+    }
+    throw error;
+  }
+  try {
+    (options?.syncDirectory ?? syncDirectory)(directoryPath);
+    return { path, record: value, durability: "confirmed" };
+  } catch (error) {
+    const durabilityErrorCode = errorCode(error);
+    return {
+      path,
+      record: value,
+      durability: "uncertain",
+      ...(durabilityErrorCode ? { durabilityErrorCode } : {}),
+    };
+  }
+}
+
+export function ensurePrivateDirectory(path, options) {
+  const directoryPath = resolve(path);
+  const durableBoundary = privateDirectoryBoundary(
+    directoryPath,
+    options?.durableBoundary,
+  );
+  mkdirSync(directoryPath, { recursive: true, mode: 0o700 });
+  if (process.platform === "win32") return;
+  chmodSync(directoryPath, 0o700);
+  const sync = options?.syncDirectory ?? syncDirectory;
+  let current = directoryPath;
+  while (true) {
+    sync(current);
+    if (current === durableBoundary) return;
+    const parent = dirname(current);
+    if (parent === current) {
+      throw new Error("private directory durable boundary was not reached");
+    }
+    current = parent;
+  }
+}
+
+function privateDirectoryBoundary(directoryPath, boundary) {
+  if (typeof boundary !== "string" || !boundary.trim()) {
+    throw new TypeError("private directory requires an explicit durable boundary");
+  }
+  const boundaryPath = resolve(boundary);
+  const childPath = relative(boundaryPath, directoryPath);
+  if (childPath === ""
+    || (childPath !== ".."
+      && !childPath.startsWith(`..${sep}`)
+      && !isAbsolute(childPath))) {
+    return boundaryPath;
+  }
+  throw new RangeError("private directory must be contained by its durable boundary");
+}
+
+function syncDirectory(directoryPath) {
+  if (process.platform === "win32") return;
+  let descriptor;
+  try {
+    descriptor = openSync(directoryPath, "r");
+    fsyncSync(descriptor);
+  } finally {
+    if (descriptor !== undefined) closeSync(descriptor);
+  }
+}
+
+function errorCode(error) {
+  return typeof error === "object"
+    && error !== null
+    && "code" in error
+    && typeof error.code === "string"
+    ? error.code
+    : undefined;
+}
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

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

@@ -0,0 +1,100 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+export function resolveWindowsCliInvocation(command, args, options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform !== "win32") return { command, args };
+  const pathApi = path.win32;
+  const fileExists = options.existsSync ?? existsSync;
+  const env = options.env ?? process.env;
+  let resolvedCommand = options.resolvedCommand;
+  if (!resolvedCommand && !/[\\/]/.test(command)) {
+    const located = options.whereOutput === undefined
+      ? (options.spawnSync ?? spawnSync)("where.exe", [command], {
+        env,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+      })
+      : { status: 0, stdout: options.whereOutput };
+    if (located.status === 0) {
+      resolvedCommand = selectWindowsCommandCandidate(command, located.stdout);
+    }
+  }
+  resolvedCommand ??= command;
+  if (/\.(?:exe|com)$/i.test(resolvedCommand)) return { command: resolvedCommand, args };
+  if (!/\.(?:cmd|bat)$/i.test(resolvedCommand)) {
+    throw new Error(`refusing to execute unsupported Windows command shim: ${resolvedCommand}`);
+  }
+
+  const name = pathApi.basename(resolvedCommand).replace(/\.(?:cmd|bat)$/i, "").toLowerCase();
+  const nativeCli = nativeCliEntrypointCandidates(name, resolvedCommand, env, pathApi)
+    .filter(isNativeEntrypoint)
+    .find((candidate) => fileExists(candidate));
+  if (nativeCli) return { command: nativeCli, args };
+  const cli = cliEntrypointCandidates(name, resolvedCommand, env, pathApi)
+    .filter(isNodeEntrypoint)
+    .find((candidate) => fileExists(candidate));
+  if (!cli) {
+    const override = name === "claude" ? "MEMORAX_CODE_CLAUDE_CLI_JS" : "MEMORAX_CODE_CODEX_CLI_JS";
+    throw new Error(
+      `refusing to execute ${pathApi.basename(resolvedCommand)} through a command shell; `
+      + `set ${override} to its Node entrypoint`,
+    );
+  }
+  return { command: options.nodePath ?? process.execPath, args: [cli, ...args] };
+}
+
+function nativeCliEntrypointCandidates(name, command, env, pathApi) {
+  if (name !== "claude") return [];
+  const root = pathApi.dirname(command);
+  return [
+    env.MEMORAX_CODE_CLAUDE_CLI_EXE,
+    env.CLAUDE_CLI_EXE,
+    pathApi.join(root, "node_modules", "@anthropic-ai", "claude-code", "bin", "claude.exe"),
+    pathApi.join(root, "..", "@anthropic-ai", "claude-code", "bin", "claude.exe"),
+  ];
+}
+
+function cliEntrypointCandidates(name, command, env, pathApi) {
+  const root = pathApi.dirname(command);
+  if (name === "codex") {
+    return [
+      env.MEMORAX_CODE_CODEX_CLI_JS,
+      env.CODEX_CLI_JS,
+      pathApi.join(root, "node_modules", "@openai", "codex", "bin", "codex.js"),
+      pathApi.join(root, "..", "@openai", "codex", "bin", "codex.js"),
+    ];
+  }
+  if (name === "claude") {
+    return [
+      env.MEMORAX_CODE_CLAUDE_CLI_JS,
+      env.CLAUDE_CLI_JS,
+      pathApi.join(root, "node_modules", "@anthropic-ai", "claude-code", "cli.js"),
+      pathApi.join(root, "..", "@anthropic-ai", "claude-code", "cli.js"),
+    ];
+  }
+  return [];
+}
+
+function isNativeEntrypoint(value) {
+  return typeof value === "string" && /\.(?:exe|com)$/i.test(value);
+}
+
+function isNodeEntrypoint(value) {
+  return typeof value === "string" && /\.(?:cjs|js|mjs)$/i.test(value);
+}
+
+export function selectWindowsCommandCandidate(command, output) {
+  const candidates = String(output ?? "")
+    .split(/\r?\n/)
+    .map((value) => value.trim())
+    .filter(Boolean);
+  const selected = candidates.find((value) => /\.(?:cmd|bat)$/i.test(value))
+    ?? candidates.find((value) => /\.(?:exe|com)$/i.test(value));
+  if (!selected) {
+    throw new Error(`where.exe did not return a safe executable or command shim for ${command}`);
+  }
+  return selected;
+}

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

@@ -0,0 +1,13 @@
+{
+  "name": "@memorax-code/claude-adapter",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "Claude Code Hook adapter for MemoraX Code memory services.",
+  "bin": {
+    "memorax-code-claude": "src/cli.mjs"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  }
+}

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/runtime-hooks/capture-cwd.mjs

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { runCaptureCwdHook } from "../memorax-code-adapter-common/src/hooks/capture-cwd-hook.mjs";
+import { markSupplementalReminderAfterCompact } from "../memorax-code-adapter-common/src/hooks/memory-skill-reminder-hook.mjs";
+import { isRepoMemoryJobWorker } from "../memorax-code-adapter-common/src/repo-memory/repo-memory-job-context.mjs";
+
+if (isRepoMemoryJobWorker()) process.exit(0);
+
+const options = {
+  adapterDir: "claude-code",
+  debugEnv: "MEMORAX_CODE_CLAUDE_HOOK_DEBUG",
+  runtime: "claude-code",
+  sessionIdField: "claudeSessionId",
+  sessionKeyPrefix: "claude",
+};
+
+const input = await runCaptureCwdHook(options);
+markSupplementalReminderAfterCompact(options, input);

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

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  runEnsureBackendHook,
+  stringValue,
+} from "../memorax-code-adapter-common/src/hooks/ensure-backend-runner.mjs";
+
+const DEBUG = process.env.MEMORAX_CODE_CLAUDE_HOOK_DEBUG === "1";
+
+try {
+  await runEnsureBackendHook({
+    ensureBackendValue: process.env.MEMORAX_CODE_CLAUDE_ENSURE_BACKEND
+      ?? process.env.MEMORAX_CODE_CLAUDE_HOOK_ENSURE_BACKEND,
+    healthTimeoutValue: process.env.MEMORAX_CODE_CLAUDE_ENSURE_TIMEOUT_MS,
+    startTimeoutValue: process.env.MEMORAX_CODE_CLAUDE_START_TIMEOUT_MS,
+    memoraxCodeCommand: stringValue(process.env.MEMORAX_CODE_CLAUDE_LIFECYCLE_COMMAND)
+      ?? stringValue(process.env.MEMORAX_CODE_COMMAND),
+    pluginRoot: pluginRoot(),
+    resolveHomes: hookHomes,
+    buildStartArgs: startArgs,
+    debug,
+  });
+} catch (error) {
+  debug(error instanceof Error ? error.message : String(error));
+}
+
+process.exit(0);
+
+function pluginRoot() {
+  return stringValue(process.env.CLAUDE_PLUGIN_ROOT)
+    ?? stringValue(process.env.PLUGIN_ROOT)
+    ?? dirname(dirname(fileURLToPath(import.meta.url)));
+}
+
+function hookHomes(input = {}) {
+  const memoraxCodeHome = stringValue(process.env.MEMORAX_CODE_HOME) ?? join(homedir(), ".memorax-code");
+  const claudeHome = stringValue(process.env.CLAUDE_CONFIG_DIR)
+    ?? stringValue(input.claude_home)
+    ?? stringValue(input.claudeHome)
+    ?? join(homedir(), ".claude");
+  return { memoraxCodeHome, claudeHome };
+}
+
+function startArgs(homes, recoveryArguments) {
+  return [
+    "start",
+    "--home",
+    homes.memoraxCodeHome,
+    "--claude-home",
+    homes.claudeHome,
+    ...recoveryArguments,
+  ];
+}
+
+function debug(message) {
+  if (DEBUG) console.error(message);
+}

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/runtime-hooks/memory-cli-session.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { appendFile } from "node:fs/promises";
+import { readStdinJson } from "../memorax-code-adapter-common/src/config-utils.mjs";
+import { isRepoMemoryJobWorker } from "../memorax-code-adapter-common/src/repo-memory/repo-memory-job-context.mjs";
+
+if (isRepoMemoryJobWorker()) process.exit(0);
+
+try {
+  const input = await readStdinJson();
+  const sessionId = stringValue(input.session_id) ?? stringValue(input.sessionId);
+  const envFile = stringValue(process.env.CLAUDE_ENV_FILE);
+  if (sessionId && envFile) {
+    await appendFile(envFile, [
+      "export MEMORAX_CODE_MEMORY_CLI_TRACE_CLIENT='claude'",
+      `export MEMORAX_CODE_MEMORY_CLI_TRACE_SESSION_ID=${shellSingleQuote(sessionId)}`,
+      "",
+    ].join("\n"), "utf8");
+  }
+} catch (error) {
+  if (process.env.MEMORAX_CODE_CLAUDE_HOOK_DEBUG === "1") {
+    console.error(error instanceof Error ? error.message : String(error));
+  }
+}
+
+process.exit(0);
+
+function shellSingleQuote(value) {
+  return `'${value.replaceAll("'", "'\"'\"'")}'`;
+}
+
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/runtime-hooks/memory-skill-reminder.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import {
+  personalMemoryReminderContext,
+  runMemorySkillReminderHook,
+} from "../memorax-code-adapter-common/src/hooks/memory-skill-reminder-hook.mjs";
+import { resolveBackendConnection } from "../memorax-code-adapter-common/src/backend-connection.mjs";
+import { isRepoMemoryJobWorker } from "../memorax-code-adapter-common/src/repo-memory/repo-memory-job-context.mjs";
+import { buildRepoProcedureMemoryContext } from "../memorax-code-adapter-common/src/repo-memory/repo-procedure-memory-context.mjs";
+import { buildRepoUserProfilePreferencesContext } from "../memorax-code-adapter-common/src/repo-memory/repo-user-profile-context.mjs";
+
+const MAX_REMINDER_TRACE_TIMEOUT_MS = 1000;
+const MEMORY_SKILL_INVOCATION = "/memorax-code-claude-adapter:memorax-code";
+
+if (isRepoMemoryJobWorker()) process.exit(0);
+
+const personalMemoryContextOptions = {
+  adapterDir: "claude-code",
+  debugEnv: "MEMORAX_CODE_CLAUDE_HOOK_DEBUG",
+  sessionKeyPrefix: "claude",
+};
+
+await runMemorySkillReminderHook({
+  additionalReminderContext: personalMemoryReminderContext(MEMORY_SKILL_INVOCATION),
+  adapterDir: "claude-code",
+  buildCadenceReminderContext: (hookInput) => buildRepoProcedureMemoryContext(hookInput, personalMemoryContextOptions),
+  buildPersonalMemoryContext: (hookInput) => buildRepoUserProfilePreferencesContext(hookInput, personalMemoryContextOptions),
+  debugEnv: "MEMORAX_CODE_CLAUDE_HOOK_DEBUG",
+  memorySkillInvocation: MEMORY_SKILL_INVOCATION,
+  onReminder: recordReminder,
+  remindOnFirstTurn: true,
+  runtime: "claude-code",
+  supplementalReminderAfterCompact: true,
+});
+
+async function recordReminder(reminder) {
+  const promptId = reminder.turnId;
+  if (!promptId || !reminder.transcriptPath) return;
+  const connection = resolveBackendConnection();
+  const timeoutMs = Math.min(
+    parsePositiveInt(
+      process.env.MEMORAX_CODE_CLAUDE_MEMORY_HOOK_TIMEOUT_MS,
+      MAX_REMINDER_TRACE_TIMEOUT_MS,
+    ),
+    MAX_REMINDER_TRACE_TIMEOUT_MS,
+  );
+  const headers = { "content-type": "application/json", connection: "close" };
+  if (connection.token) headers["x-memorax-code-backend-token"] = connection.token;
+  const response = await fetch(new URL("/memory/skill-reminder", connection.url), {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      version: 1,
+      client: "claude-code",
+      sessionId: reminder.sessionId,
+      promptId,
+      transcriptPath: reminder.transcriptPath,
+      cwd: reminder.cwd,
+      workspaceKind: reminder.workspaceKind,
+      content: reminder.content,
+      triggers: reminder.triggers,
+    }),
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  if (!response.ok) {
+    await response.arrayBuffer().catch(() => undefined);
+    throw new Error(`Backend /memory/skill-reminder returned HTTP ${response.status}`);
+  }
+}
+
+function parsePositiveInt(value, fallback) {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/runtime-hooks/memory-turn.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import { resolveBackendConnection } from "../memorax-code-adapter-common/src/backend-connection.mjs";
+import { readStdinJson } from "../memorax-code-adapter-common/src/config-utils.mjs";
+import { isRepoMemoryJobWorker } from "../memorax-code-adapter-common/src/repo-memory/repo-memory-job-context.mjs";
+
+const RETRIEVAL_BACKEND_TIMEOUT_MS = 12_000;
+const DEFAULT_BACKEND_TIMEOUT_MS = 5_000;
+
+if (isRepoMemoryJobWorker()) process.exit(0);
+
+try {
+  const input = await readStdinJson();
+  const event = stringValue(input.hook_event_name) ?? stringValue(input.hookEventName);
+  const sessionId = stringValue(input.session_id) ?? stringValue(input.sessionId);
+  const promptId = stringValue(input.prompt_id) ?? stringValue(input.promptId);
+  const transcriptPath = stringValue(input.transcript_path) ?? stringValue(input.transcriptPath);
+  if (!sessionId || !promptId || !transcriptPath) process.exit(0);
+
+  if (event === "UserPromptSubmit") {
+    const prompt = stringValue(input.prompt);
+    if (!prompt) process.exit(0);
+    const response = await postMemoryService("/memory/turn-start", {
+      version: 1,
+      client: "claude-code",
+      sessionId,
+      promptId,
+      transcriptPath,
+      prompt,
+      cwd: stringValue(input.cwd),
+      workspaceKind: stringValue(input.workspace_kind) ?? stringValue(input.workspaceKind),
+    });
+    const additionalContext = stringValue(response?.additionalContext);
+    if (additionalContext) {
+      process.stdout.write(`${JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "UserPromptSubmit",
+          additionalContext,
+        },
+      })}\n`);
+    }
+  } else if (event === "Stop") {
+    const lastAssistantMessage = stringValue(input.last_assistant_message) ?? stringValue(input.lastAssistantMessage);
+    if (!lastAssistantMessage) process.exit(0);
+    await postMemoryService("/memory/writeback", {
+      version: 1,
+      client: "claude-code",
+      sessionId,
+      promptId,
+      transcriptPath,
+      lastAssistantMessage,
+      cwd: stringValue(input.cwd),
+      workspaceKind: stringValue(input.workspace_kind) ?? stringValue(input.workspaceKind),
+    });
+  }
+} catch (error) {
+  if (process.env.MEMORAX_CODE_CLAUDE_HOOK_DEBUG === "1") {
+    console.error(error instanceof Error ? error.message : String(error));
+  }
+}
+
+process.exit(0);
+
+async function postMemoryService(path, body) {
+  const connection = resolveBackendConnection();
+  const timeoutMs = parsePositiveInt(
+    process.env.MEMORAX_CODE_CLAUDE_MEMORY_HOOK_TIMEOUT_MS,
+    path === "/memory/turn-start" ? RETRIEVAL_BACKEND_TIMEOUT_MS : DEFAULT_BACKEND_TIMEOUT_MS,
+  );
+  const headers = { "content-type": "application/json", connection: "close" };
+  if (connection.token) headers["x-memorax-code-backend-token"] = connection.token;
+  const response = await fetch(new URL(path, connection.url), {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  if (!response.ok) {
+    await response.arrayBuffer().catch(() => undefined);
+    return undefined;
+  }
+  return await response.json().catch(() => undefined);
+}
+
+function parsePositiveInt(value, fallback) {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}

package/lib/memorax-code-claude-marketplace/plugins/memorax-code-claude-adapter/scripts/build-marketplace.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+import { cp, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+  collectClaudePluginArtifactSources,
+  describeClaudePluginArtifactProblems,
+  inspectClaudePluginArtifact,
+} from "../src/plugin-artifact-contract.mjs";
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const ADAPTER_ROOT = resolve(SCRIPT_DIR, "..");
+const PLUGIN_NAME = "memorax-code-claude-adapter";
+
+export async function buildClaudeMarketplace({ outputDir, adapterRoot = ADAPTER_ROOT } = {}) {
+  if (!outputDir) throw new Error("outputDir is required");
+  const marketplaceRoot = resolve(outputDir);
+  const pluginRoot = join(marketplaceRoot, "plugins", PLUGIN_NAME);
+  const artifactSources = collectClaudePluginArtifactSources({ adapterRoot });
+
+  await rm(marketplaceRoot, { recursive: true, force: true });
+  await mkdir(join(marketplaceRoot, ".claude-plugin"), { recursive: true });
+  await mkdir(pluginRoot, { recursive: true });
+
+  await writeFile(
+    join(marketplaceRoot, ".claude-plugin", "marketplace.json"),
+    `${JSON.stringify({
+      name: "memorax-code-local",
+      description: "MemoraX Code integration for Claude Code.",
+      owner: {
+        name: "MemoraX Code Local",
+      },
+      plugins: [
+        {
+          name: PLUGIN_NAME,
+          displayName: "MemoraX Code",
+          source: `./plugins/${PLUGIN_NAME}`,
+          description: "Connect Claude Code to MemoraX Code memory.",
+        },
+      ],
+    }, null, 2)}\n`
+  );
+
+  for (const source of artifactSources) {
+    const destination = join(pluginRoot, ...source.relativePath.split("/"));
+    await mkdir(dirname(destination), { recursive: true });
+    await cp(source.sourcePath, destination, { force: true });
+  }
+  await rewriteAdapterCommonImports(pluginRoot);
+  const inspection = inspectClaudePluginArtifact(pluginRoot, artifactSources);
+  if (!inspection.ok) {
+    throw new Error(
+      `generated Claude plugin violates its artifact contract: ${describeClaudePluginArtifactProblems(inspection)}`,
+    );
+  }
+
+  return {
+    ok: true,
+    marketplaceRoot,
+    pluginName: PLUGIN_NAME,
+    pluginRoot,
+  };
+}
+
+async function rewriteAdapterCommonImports(pluginRoot) {
+  for (const dir of ["hooks", "runtime-hooks", "src"]) {
+    for (const path of await mjsFiles(join(pluginRoot, dir))) {
+      const text = await readFile(path, "utf8");
+      const next = text.replaceAll("../../memorax-code-adapter-common/src/", "../memorax-code-adapter-common/src/");
+      if (next !== text) await writeFile(path, next, "utf8");
+    }
+  }
+}
+
+async function mjsFiles(root) {
+  const files = [];
+  for (const entry of await readdir(root, { withFileTypes: true })) {
+    const path = join(root, entry.name);
+    if (entry.isDirectory()) files.push(...await mjsFiles(path));
+    else if (entry.isFile() && entry.name.endsWith(".mjs")) files.push(path);
+  }
+  return files;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  try {
+    const outputDir = process.argv[2];
+    const adapterRoot = process.argv[3];
+    if (!outputDir) throw new Error("usage: build-marketplace.mjs <output-dir> [adapter-root]");
+    const result = await buildClaudeMarketplace({
+      outputDir,
+      ...(adapterRoot ? { adapterRoot } : {}),
+    });
+    console.log(JSON.stringify(result));
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}