@memoraone/mcp 0.1.5 → 0.1.6

package/dist/cli.cjs

@@ -0,0 +1,797 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// src/config.ts
+var process2 = __toESM(require("process"), 1);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_dotenv = __toESM(require("dotenv"), 1);
+var import_v4 = require("zod/v4");
+
+// src/configUtils.ts
+var DEFAULT_API_URL = "https://api.memoraone.com";
+var DEV_API_URL = "http://localhost:3001";
+function resolveApiUrl(env2) {
+  const explicitUrl = env2.MEMORAONE_API_URL?.trim();
+  if (explicitUrl) {
+    return explicitUrl;
+  }
+  if (env2.MEMORAONE_DEV_MODE === "1") {
+    return DEV_API_URL;
+  }
+  return DEFAULT_API_URL;
+}
+
+// src/config.ts
+var dotenvPath = path.resolve(process2.cwd(), ".env");
+if (fs.existsSync(dotenvPath)) {
+  try {
+    import_dotenv.default.config({ path: dotenvPath });
+  } catch (err) {
+    process2.stderr.write("[memoraone-mcp] Failed to load .env: " + String(err) + "\n");
+  }
+}
+var EnvSchema = import_v4.z.object({
+  MEMORAONE_API_URL: import_v4.z.string().url().optional(),
+  MEMORAONE_API_KEY: import_v4.z.string().min(1),
+  MEMORAONE_DEV_MODE: import_v4.z.string().min(1).optional(),
+  MEMORAONE_AGENT_NAME: import_v4.z.string().min(1).optional(),
+  MEMORAONE_AGENT_TYPE: import_v4.z.string().min(1).optional(),
+  MEMORAONE_SOURCE: import_v4.z.string().min(1).optional(),
+  MEMORAONE_WORKLOG: import_v4.z.string().min(1).optional(),
+  MEMORAONE_HEARTBEAT: import_v4.z.string().min(1).optional(),
+  MEMORAONE_HEARTBEAT_INTERVAL_MS: import_v4.z.string().min(1).optional()
+});
+var requiredEnvVars = ["MEMORAONE_API_KEY"];
+var missingEnvVars = requiredEnvVars.filter((key) => {
+  const value = process2.env[key];
+  return value === void 0 || value.trim() === "";
+});
+if (missingEnvVars.length > 0) {
+  for (const key of missingEnvVars) {
+    process2.stderr.write(`Missing ${key}
+`);
+  }
+  process2.exit(1);
+}
+var parsed = EnvSchema.safeParse(process2.env);
+var resolvedApiUrl = resolveApiUrl(process2.env);
+if (!parsed.success) {
+  const formatted = parsed.error.format();
+  process2.stderr.write(
+    "[memoraone-mcp] Invalid environment variables " + JSON.stringify(formatted) + "\n"
+  );
+  throw new Error("Config validation failed");
+}
+var parseBooleanFlag = (value, defaultValue) => {
+  if (value === void 0) {
+    return defaultValue;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["0", "false", "no", "off"].includes(normalized)) {
+    return false;
+  }
+  return defaultValue;
+};
+var config = {
+  apiUrl: resolvedApiUrl.replace(/\/+$/, ""),
+  apiKey: parsed.data.MEMORAONE_API_KEY,
+  agentName: parsed.data.MEMORAONE_AGENT_NAME ?? "cursor",
+  agentType: parsed.data.MEMORAONE_AGENT_TYPE ?? "agent",
+  source: parsed.data.MEMORAONE_SOURCE ?? "cursor",
+  worklogEnabled: parseBooleanFlag(parsed.data.MEMORAONE_WORKLOG, true),
+  heartbeatEnabled: parseBooleanFlag(parsed.data.MEMORAONE_HEARTBEAT, true),
+  heartbeatIntervalMs: Number.parseInt(parsed.data.MEMORAONE_HEARTBEAT_INTERVAL_MS ?? "30000", 10)
+};
+
+// src/client/memoraClient.ts
+async function requestJson(url, method, headers, body) {
+  const res = await fetch(url, {
+    method,
+    headers,
+    body: method === "GET" ? void 0 : JSON.stringify(body ?? {})
+  });
+  const text = await res.text();
+  return {
+    status: res.status,
+    statusText: res.statusText,
+    ok: res.ok,
+    text
+  };
+}
+var MemoraOneHttpError = class extends Error {
+  constructor(status, statusText, body) {
+    super(`MemoraOne request failed: ${status} ${statusText}`);
+    this.name = "MemoraOneHttpError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var MemoraClient = class {
+  constructor(cfg) {
+    this.baseUrl = cfg.apiUrl;
+    this.apiKey = cfg.apiKey;
+  }
+  buildHeaders(options) {
+    return {
+      "content-type": "application/json",
+      "x-api-key": this.apiKey,
+      ...options?.headers ?? {}
+    };
+  }
+  async post(path2, body, options) {
+    const url = `${this.baseUrl}${path2.startsWith("/") ? path2 : `/${path2}`}`;
+    process.stderr.write(
+      `[memoraone-mcp] http url=${url} apiKeyPrefix=${String(this.apiKey).slice(0, 8)} apiKeyLen=${String(this.apiKey).length}
+`
+    );
+    const res = await requestJson(url, "POST", this.buildHeaders(options), body);
+    if (!res.ok) {
+      throw new MemoraOneHttpError(res.status, res.statusText, res.text);
+    }
+    return res.text ? JSON.parse(res.text) : null;
+  }
+  async get(path2, options) {
+    const url = `${this.baseUrl}${path2.startsWith("/") ? path2 : `/${path2}`}`;
+    const res = await requestJson(url, "GET", this.buildHeaders(options));
+    if (!res.ok) {
+      throw new MemoraOneHttpError(res.status, res.statusText, res.text);
+    }
+    return res.text ? JSON.parse(res.text) : null;
+  }
+};
+var memoraClient_default = MemoraClient;
+
+// src/tools/postEvent.ts
+var import_v42 = require("zod/v4");
+var postEventShape = {
+  kind: import_v42.z.string().min(1),
+  actor: import_v42.z.object({ identifier: import_v42.z.string().min(1) }),
+  content: import_v42.z.record(import_v42.z.string(), import_v42.z.any()),
+  metadata: import_v42.z.record(import_v42.z.string(), import_v42.z.any()).optional()
+};
+
+// src/tools/askWithMemory.ts
+var import_v43 = require("zod/v4");
+var askWithMemoryShape = {
+  question: import_v43.z.string().min(1),
+  code_context: import_v43.z.object({
+    file_path: import_v43.z.string().optional(),
+    selected_text: import_v43.z.string().optional(),
+    language: import_v43.z.string().optional()
+  }).optional()
+};
+
+// src/tools/logIntent.ts
+var import_v44 = require("zod/v4");
+var logIntentShape = {
+  intent: import_v44.z.enum(["task", "decision"]),
+  message: import_v44.z.string().min(1),
+  context: import_v44.z.record(import_v44.z.string(), import_v44.z.any()).optional(),
+  intent_source: import_v44.z.string().optional().default("cursor_chat"),
+  run_id: import_v44.z.string().min(1).optional()
+};
+
+// src/tools/logChangeSummary.ts
+var import_v45 = require("zod/v4");
+var logChangeSummaryShape = {
+  summary: import_v45.z.string().min(1),
+  scope: import_v45.z.string().min(1).optional(),
+  files: import_v45.z.array(import_v45.z.string().min(1)).optional(),
+  stats: import_v45.z.object({
+    files: import_v45.z.number().int().nonnegative().optional(),
+    add: import_v45.z.number().int().nonnegative().optional(),
+    del: import_v45.z.number().int().nonnegative().optional()
+  }).optional(),
+  commit: import_v45.z.string().min(1).optional(),
+  run_id: import_v45.z.string().min(1).optional()
+};
+
+// src/tools/logToolResult.ts
+var import_v46 = require("zod/v4");
+var logToolResultShape = {
+  tool: import_v46.z.string().min(1),
+  status: import_v46.z.enum(["ok", "error", "partial"]),
+  summary: import_v46.z.string().min(1),
+  run_id: import_v46.z.string().min(1).optional(),
+  duration_ms: import_v46.z.number().int().nonnegative().optional(),
+  error_code: import_v46.z.string().min(1).optional(),
+  error_message: import_v46.z.string().min(1).optional(),
+  error_kind: import_v46.z.enum(["infra", "logic", "auth", "rate_limit", "validation", "unknown"]).optional(),
+  stats: import_v46.z.record(import_v46.z.string(), import_v46.z.any()).optional()
+};
+
+// src/tools/logCommand.ts
+var import_v47 = require("zod/v4");
+var logCommandShape = {
+  cmd: import_v47.z.string().min(1),
+  summary: import_v47.z.string().min(1),
+  cwd: import_v47.z.string().min(1).optional(),
+  exit_code: import_v47.z.number().int().optional(),
+  duration_ms: import_v47.z.number().int().nonnegative().optional(),
+  run_id: import_v47.z.string().min(1).optional(),
+  stats: import_v47.z.record(import_v47.z.string(), import_v47.z.any()).optional()
+};
+
+// src/tools/listProjects.ts
+var listProjectsShape = {};
+
+// src/tools/setProject.ts
+var import_v48 = require("zod/v4");
+var setProjectShape = {
+  projectId: import_v48.z.string().min(1)
+};
+
+// src/tools/handlers/postEvent.ts
+var import_v49 = require("zod/v4");
+
+// src/runContext.ts
+var crypto = __toESM(require("crypto"), 1);
+var currentRunId = null;
+var currentProjectId = null;
+function setCurrentRunId(id) {
+  currentRunId = id;
+}
+function getCurrentProjectId() {
+  return currentProjectId;
+}
+function setCurrentProjectId(id) {
+  currentProjectId = id;
+}
+function resolveRunId(passed) {
+  if (passed) {
+    return passed;
+  }
+  return currentRunId;
+}
+function generateRunId() {
+  return crypto.randomBytes(16).toString("hex");
+}
+
+// src/tools/handlers/postEvent.ts
+var postEventInputSchema = import_v49.z.object({
+  kind: import_v49.z.string().min(1),
+  actor: import_v49.z.object({ identifier: import_v49.z.string().min(1) }),
+  content: import_v49.z.record(import_v49.z.string(), import_v49.z.any()),
+  metadata: import_v49.z.record(import_v49.z.string(), import_v49.z.any()).optional()
+});
+async function handlePostEvent(client, args) {
+  const parsed2 = postEventInputSchema.parse(args ?? {});
+  const projectId = getCurrentProjectId();
+  if (!projectId) {
+    throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
+  }
+  const body = {
+    kind: parsed2.kind,
+    actor: { type: config.agentType, identifier: parsed2.actor.identifier },
+    content: parsed2.content,
+    metadata: {
+      source: config.source,
+      ...parsed2.metadata
+    }
+  };
+  await client.post("/timeline/events", body, { projectId });
+  return { ok: true, forwarded: true };
+}
+
+// src/tools/handlers/askWithMemory.ts
+var import_v410 = require("zod/v4");
+var askWithMemoryInputSchema = import_v410.z.object({
+  question: import_v410.z.string().min(1),
+  code_context: import_v410.z.object({
+    file_path: import_v410.z.string().optional(),
+    selected_text: import_v410.z.string().optional(),
+    language: import_v410.z.string().optional()
+  }).optional()
+});
+function isAskWithMemoryResponse(value) {
+  return typeof value === "object" && value !== null && typeof value.answer === "string" && value.answer !== "";
+}
+async function handleAskWithMemory(client, args) {
+  const parsed2 = askWithMemoryInputSchema.parse(args ?? {});
+  const projectId = getCurrentProjectId();
+  if (!projectId) {
+    throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
+  }
+  const payload = {
+    question: parsed2.question
+  };
+  if (parsed2.code_context) {
+    payload.code_context = parsed2.code_context;
+  }
+  const res = await client.post("/agent/ask-with-memory", payload, { projectId });
+  if (!isAskWithMemoryResponse(res)) {
+    const err = new Error("Unexpected response from MemoraOne");
+    err.status = 502;
+    err.body = res;
+    throw err;
+  }
+  return {
+    answer: res.answer,
+    used: res.used ?? {}
+  };
+}
+
+// src/tools/handlers/logIntent.ts
+var import_v411 = require("zod/v4");
+var logIntentInputSchema = import_v411.z.object({
+  intent: import_v411.z.enum(["task", "decision"]),
+  message: import_v411.z.string().min(1),
+  context: import_v411.z.record(import_v411.z.string(), import_v411.z.any()).optional(),
+  intent_source: import_v411.z.string().optional().default("cursor_chat"),
+  run_id: import_v411.z.string().min(1).optional()
+});
+async function handleLogIntent(client, args) {
+  const parsed2 = logIntentInputSchema.parse(args ?? {});
+  const projectId = getCurrentProjectId();
+  if (!projectId) {
+    throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
+  }
+  const intent = parsed2.intent;
+  const message = parsed2.message.trim();
+  if (!message) {
+    throw new Error("message cannot be empty after trimming");
+  }
+  const intent_source = parsed2.intent_source ?? "cursor_chat";
+  const context = parsed2.context;
+  const purpose = intent;
+  const concept = purpose === "task" ? "concept:task" : "concept:decision";
+  const run_id = parsed2.run_id ?? generateRunId();
+  setCurrentRunId(run_id);
+  const body = {
+    kind: "note",
+    actor: { type: config.agentType, name: config.agentName },
+    concept,
+    // MUST be TOP-LEVEL so it populates timeline_events.concept
+    message,
+    metadata: {
+      source: config.source,
+      purpose,
+      // 'task' | 'decision'
+      intent_source: intent_source ?? "cursor_chat",
+      run_id,
+      ...context ? { context } : {}
+    }
+  };
+  await client.post("/timeline/events", body, { projectId });
+  return { ok: true, run_id };
+}
+
+// src/tools/handlers/logChangeSummary.ts
+var import_v412 = require("zod/v4");
+var logChangeSummaryInputSchema = import_v412.z.object({
+  summary: import_v412.z.string().min(1),
+  scope: import_v412.z.string().min(1).optional(),
+  files: import_v412.z.array(import_v412.z.string().min(1)).optional(),
+  stats: import_v412.z.object({
+    files: import_v412.z.number().int().nonnegative().optional(),
+    add: import_v412.z.number().int().nonnegative().optional(),
+    del: import_v412.z.number().int().nonnegative().optional()
+  }).optional(),
+  commit: import_v412.z.string().min(1).optional(),
+  run_id: import_v412.z.string().min(1).optional()
+});
+async function handleLogChangeSummary(client, args) {
+  const parsed2 = logChangeSummaryInputSchema.parse(args ?? {});
+  const projectId = getCurrentProjectId();
+  if (!projectId) {
+    throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
+  }
+  const { summary, scope, files, stats, commit } = parsed2;
+  const message = summary.startsWith("CHANGE:") ? summary : `CHANGE: ${scope ?? "code"} \u2014 ${summary}`;
+  const run_id = resolveRunId(parsed2.run_id);
+  const body = {
+    kind: "note",
+    concept: "concept:change_summary",
+    actor: { type: config.agentType, name: config.agentName },
+    message,
+    metadata: {
+      source: config.source,
+      purpose: "change_summary",
+      tool: "memora_log_change_summary",
+      ...scope ? { scope } : {},
+      ...files ? { files } : {},
+      ...stats ? { stats } : {},
+      ...commit ? { commit } : {},
+      ...run_id ? { run_id } : {}
+    }
+  };
+  await client.post("/timeline/events", body, { projectId });
+  return { ok: true };
+}
+
+// src/tools/handlers/logToolResult.ts
+var import_v413 = require("zod/v4");
+var logToolResultInputSchema = import_v413.z.object({
+  tool: import_v413.z.string().min(1),
+  status: import_v413.z.enum(["ok", "error", "partial"]),
+  summary: import_v413.z.string().min(1),
+  run_id: import_v413.z.string().min(1).optional(),
+  duration_ms: import_v413.z.number().int().nonnegative().optional(),
+  error_code: import_v413.z.string().min(1).optional(),
+  error_message: import_v413.z.string().min(1).optional(),
+  error_kind: import_v413.z.enum(["infra", "logic", "auth", "rate_limit", "validation", "unknown"]).optional(),
+  stats: import_v413.z.record(import_v413.z.string(), import_v413.z.any()).optional()
+});
+async function handleLogToolResult(client, args) {
+  const parsed2 = logToolResultInputSchema.parse(args ?? {});
+  const projectId = getCurrentProjectId();
+  if (!projectId) {
+    throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
+  }
+  const { tool, status, summary, duration_ms, error_code, error_message, error_kind, stats } = parsed2;
+  const message = summary.startsWith("RESULT:") ? summary : `RESULT: ${tool} \u2014 ${status} \u2014 ${summary}`;
+  const run_id = resolveRunId(parsed2.run_id);
+  const body = {
+    kind: "note",
+    concept: "concept:tool_result",
+    actor: { type: config.agentType, name: config.agentName },
+    message,
+    metadata: {
+      source: config.source,
+      purpose: "tool_result",
+      tool: "memora_log_tool_result",
+      tool_name: tool,
+      status,
+      ...run_id ? { run_id } : {},
+      ...duration_ms ? { duration_ms } : {},
+      ...error_code ? { error_code } : {},
+      ...error_message ? { error_message } : {},
+      ...error_kind ? { error_kind } : {},
+      ...stats ? { stats } : {}
+    }
+  };
+  await client.post("/timeline/events", body, { projectId });
+  return { ok: true };
+}
+
+// src/tools/handlers/logCommand.ts
+var import_v414 = require("zod/v4");
+var logCommandInputSchema = import_v414.z.object({
+  cmd: import_v414.z.string().min(1),
+  summary: import_v414.z.string().min(1),
+  cwd: import_v414.z.string().min(1).optional(),
+  exit_code: import_v414.z.number().int().optional(),
+  duration_ms: import_v414.z.number().int().nonnegative().optional(),
+  run_id: import_v414.z.string().min(1).optional(),
+  stats: import_v414.z.record(import_v414.z.string(), import_v414.z.any()).optional()
+});
+async function handleLogCommand(client, args) {
+  const parsed2 = logCommandInputSchema.parse(args ?? {});
+  const projectId = getCurrentProjectId();
+  if (!projectId) {
+    throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
+  }
+  const { cmd, summary, cwd: cwd2, exit_code, duration_ms, stats } = parsed2;
+  const message = summary.startsWith("COMMAND:") ? summary : `COMMAND: ${cmd} \u2014 ${summary}`;
+  const run_id = resolveRunId(parsed2.run_id);
+  const body = {
+    kind: "note",
+    concept: "concept:command",
+    actor: { type: config.agentType, name: config.agentName },
+    message,
+    metadata: {
+      source: config.source,
+      purpose: "command",
+      tool: "memora_log_command",
+      cmd,
+      ...cwd2 ? { cwd: cwd2 } : {},
+      ...exit_code !== void 0 ? { exit_code } : {},
+      ...duration_ms !== void 0 ? { duration_ms } : {},
+      ...run_id ? { run_id } : {},
+      ...stats ? { stats } : {}
+    }
+  };
+  await client.post("/timeline/events", body, { projectId });
+  return { ok: true };
+}
+
+// src/tools/handlers/listProjects.ts
+async function handleListProjects(client) {
+  const res = await client.get("/admin/projects");
+  return res ?? { items: [] };
+}
+
+// src/tools/handlers/setProject.ts
+var import_v415 = require("zod/v4");
+var setProjectInputSchema = import_v415.z.object({
+  projectId: import_v415.z.string().min(1)
+});
+async function handleSetProject(args) {
+  const parsed2 = setProjectInputSchema.parse(args ?? {});
+  setCurrentProjectId(parsed2.projectId);
+  return { ok: true, projectId: parsed2.projectId };
+}
+
+// src/index.ts
+async function sendHeartbeat(client) {
+  try {
+    await client.post("/admin/api-keys/heartbeat", {});
+  } catch (err) {
+    console.error("[memoraone-mcp] heartbeat error (silent)", err);
+  }
+}
+function redactSensitiveFields(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(redactSensitiveFields);
+  const redacted = {};
+  const sensitiveKeys = /^(headers?|api[_-]?key|token|cookie|authorization|auth|password|secret|credential|bearer)$/i;
+  for (const [key, value] of Object.entries(obj)) {
+    if (sensitiveKeys.test(key)) {
+      redacted[key] = "[REDACTED]";
+    } else if (typeof value === "object") {
+      redacted[key] = redactSensitiveFields(value);
+    } else {
+      redacted[key] = value;
+    }
+  }
+  return redacted;
+}
+function sanitizeArgsSummary(args) {
+  try {
+    const redacted = redactSensitiveFields(args);
+    const summary = JSON.stringify(redacted);
+    return summary.length > 200 ? summary.slice(0, 200) + "..." : summary;
+  } catch {
+    return "[unable to serialize args]";
+  }
+}
+async function postWorklogEvent(client, message) {
+  try {
+    const body = {
+      kind: "note",
+      concept: "concept:worklog",
+      actor: { type: config.agentType, name: config.agentName },
+      message,
+      metadata: {
+        source: config.source,
+        purpose: "worklog"
+      }
+    };
+    await client.post("/timeline/events", body);
+  } catch (err) {
+    console.error("[memoraone-mcp] worklog error (silent)", err);
+  }
+}
+function registerToolWithWorklog(server, client, toolName, description, schema, handler) {
+  if (!config.worklogEnabled) {
+    server.tool(toolName, description, schema, handler);
+    return;
+  }
+  server.tool(toolName, description, schema, async (args) => {
+    const argsSummary = sanitizeArgsSummary(args);
+    const start = Date.now();
+    await postWorklogEvent(client, `tool_start: ${toolName} ${argsSummary}`);
+    try {
+      const result = await handler(args);
+      const durationMs = Date.now() - start;
+      await postWorklogEvent(client, `tool_end: ${toolName} ok (${durationMs}ms)`);
+      return result;
+    } catch (err) {
+      const durationMs = Date.now() - start;
+      const errorSummary = err?.message || String(err);
+      const shortError = errorSummary.length > 100 ? errorSummary.slice(0, 100) + "..." : errorSummary;
+      await postWorklogEvent(client, `tool_end: ${toolName} error (${durationMs}ms): ${shortError}`);
+      throw err;
+    }
+  });
+}
+async function main() {
+  const client = new memoraClient_default(config);
+  console.error(
+    `[memoraone-mcp] Agent identity: name="${config.agentName}", type="${config.agentType}", source="${config.source}"`
+  );
+  const server = new import_mcp.McpServer({
+    name: "memoraone-mcp",
+    version: "1.0.0"
+  });
+  const registeredToolNames = [];
+  registeredToolNames.push("memora_post_event");
+  registerToolWithWorklog(
+    server,
+    client,
+    "memora_post_event",
+    "Forward an event to MemoraOne timeline",
+    postEventShape,
+    async (args) => {
+      const result = await handlePostEvent(client, args);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ]
+      };
+    }
+  );
+  registeredToolNames.push("memora_list_projects");
+  server.tool(
+    "memora_list_projects",
+    "List projects available to the current API key",
+    listProjectsShape,
+    async () => {
+      const result = await handleListProjects(client);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ]
+      };
+    }
+  );
+  registeredToolNames.push("memora_set_project");
+  server.tool(
+    "memora_set_project",
+    "Set the current project id for subsequent tool calls",
+    setProjectShape,
+    async (args) => {
+      const result = await handleSetProject(args);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ]
+      };
+    }
+  );
+  registeredToolNames.push("memora_ask_with_memory");
+  registerToolWithWorklog(
+    server,
+    client,
+    "memora_ask_with_memory",
+    "Ask MemoraOne with project memory context",
+    askWithMemoryShape,
+    async (args) => {
+      const result = await handleAskWithMemory(client, args);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ]
+      };
+    }
+  );
+  registeredToolNames.push("memora_log_intent");
+  registerToolWithWorklog(
+    server,
+    client,
+    "memora_log_intent",
+    "Log a natural-language TASK or DECISION intent to the MemoraOne timeline",
+    logIntentShape,
+    async (args) => {
+      const result = await handleLogIntent(client, args);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ]
+      };
+    }
+  );
+  registeredToolNames.push("memora_log_change_summary");
+  registerToolWithWorklog(
+    server,
+    client,
+    "memora_log_change_summary",
+    "Log a concise code change summary to the MemoraOne timeline",
+    logChangeSummaryShape,
+    async (args) => {
+      const result = await handleLogChangeSummary(client, args);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ]
+      };
+    }
+  );
+  registeredToolNames.push("memora_log_tool_result");
+  registerToolWithWorklog(
+    server,
+    client,
+    "memora_log_tool_result",
+    "Log a tool execution result to the MemoraOne timeline",
+    logToolResultShape,
+    async (args) => {
+      const result = await handleLogToolResult(client, args);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ]
+      };
+    }
+  );
+  registeredToolNames.push("memora_log_command");
+  registerToolWithWorklog(
+    server,
+    client,
+    "memora_log_command",
+    "Log a command execution to the MemoraOne timeline",
+    logCommandShape,
+    async (args) => {
+      const result = await handleLogCommand(client, args);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ]
+      };
+    }
+  );
+  console.error("[memoraone-mcp] Starting MCP server with", registeredToolNames.length, "tools");
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  let heartbeatInterval = null;
+  if (config.heartbeatEnabled) {
+    if (globalThis.__memoraHeartbeatInterval) {
+      clearInterval(globalThis.__memoraHeartbeatInterval);
+    }
+    await sendHeartbeat(client);
+    const intervalMs = Number.isFinite(config.heartbeatIntervalMs) ? Math.max(1e3, config.heartbeatIntervalMs) : 3e4;
+    heartbeatInterval = setInterval(() => {
+      sendHeartbeat(client).catch(() => {
+      });
+    }, intervalMs);
+    globalThis.__memoraHeartbeatInterval = heartbeatInterval;
+  }
+  const shutdown = (signal) => {
+    if (heartbeatInterval) clearInterval(heartbeatInterval);
+    if (globalThis.__memoraHeartbeatInterval) {
+      clearInterval(globalThis.__memoraHeartbeatInterval);
+    }
+    console.error(`[memoraone-mcp] Received ${signal}, shutting down`);
+    process.exit(0);
+  };
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  console.error("[memoraone-mcp] MCP server ready");
+}
+main().catch((err) => {
+  console.error("[memoraone-mcp] fatal error", err);
+  process.exit(1);
+});