@memoraone/mcp 0.1.19 → 0.1.20

package/dist/index.cjs

@@ -491,80 +491,106 @@ var postEventShape = {
   metadata: import_v42.z.record(import_v42.z.string(), import_v42.z.any()).optional()
 };
 
-// src/tools/askWithMemory.ts
+// src/tools/createFact.ts
 var import_v43 = require("zod/v4");
+var createFactShape = {
+  content: import_v43.z.string().min(1).describe("Explicit fact text to persist for the current project"),
+  metadata: import_v43.z.record(import_v43.z.string(), import_v43.z.any()).optional()
+};
+
+// src/tools/addPersonalContext.ts
+var import_v44 = require("zod/v4");
+var addPersonalContextShape = {
+  content: import_v44.z.string().min(1).describe("Text to store (note, preference, or similar)"),
+  category: import_v44.z.string().optional().describe("Optional category label"),
+  tags: import_v44.z.array(import_v44.z.string()).optional().describe("Optional tags"),
+  scope_type: import_v44.z.enum(["general", "project"]).optional(),
+  scope_id: import_v44.z.string().optional()
+};
+
+// src/tools/getPersonalContext.ts
+var import_v45 = require("zod/v4");
+var getPersonalContextShape = {
+  query: import_v45.z.string().optional().describe("Search query; sent as q when set"),
+  scope_type: import_v45.z.enum(["general", "project"]).optional(),
+  scope_id: import_v45.z.string().optional(),
+  limit: import_v45.z.number().int().positive().optional().describe("Max items to return")
+};
+
+// src/tools/askWithMemory.ts
+var import_v46 = 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()
+  question: import_v46.z.string().min(1),
+  code_context: import_v46.z.object({
+    file_path: import_v46.z.string().optional(),
+    selected_text: import_v46.z.string().optional(),
+    language: import_v46.z.string().optional()
   }).optional()
 };
 
 // src/tools/logIntent.ts
-var import_v44 = require("zod/v4");
+var import_v47 = 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()
+  intent: import_v47.z.enum(["task", "decision"]),
+  message: import_v47.z.string().min(1),
+  context: import_v47.z.record(import_v47.z.string(), import_v47.z.any()).optional(),
+  intent_source: import_v47.z.string().optional().default("cursor_chat"),
+  run_id: import_v47.z.string().min(1).optional()
 };
 
 // src/tools/logChangeSummary.ts
-var import_v45 = require("zod/v4");
+var import_v48 = 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()
+  summary: import_v48.z.string().min(1),
+  scope: import_v48.z.string().min(1).optional(),
+  files: import_v48.z.array(import_v48.z.string().min(1)).optional(),
+  stats: import_v48.z.object({
+    files: import_v48.z.number().int().nonnegative().optional(),
+    add: import_v48.z.number().int().nonnegative().optional(),
+    del: import_v48.z.number().int().nonnegative().optional()
   }).optional(),
-  commit: import_v45.z.string().min(1).optional(),
-  run_id: import_v45.z.string().min(1).optional()
+  commit: import_v48.z.string().min(1).optional(),
+  run_id: import_v48.z.string().min(1).optional()
 };
 
 // src/tools/logToolResult.ts
-var import_v46 = require("zod/v4");
+var import_v49 = 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()
+  tool: import_v49.z.string().min(1),
+  status: import_v49.z.enum(["ok", "error", "partial"]),
+  summary: import_v49.z.string().min(1),
+  run_id: import_v49.z.string().min(1).optional(),
+  duration_ms: import_v49.z.number().int().nonnegative().optional(),
+  error_code: import_v49.z.string().min(1).optional(),
+  error_message: import_v49.z.string().min(1).optional(),
+  error_kind: import_v49.z.enum(["infra", "logic", "auth", "rate_limit", "validation", "unknown"]).optional(),
+  stats: import_v49.z.record(import_v49.z.string(), import_v49.z.any()).optional()
 };
 
 // src/tools/logCommand.ts
-var import_v47 = require("zod/v4");
+var import_v410 = 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()
+  cmd: import_v410.z.string().min(1),
+  summary: import_v410.z.string().min(1),
+  cwd: import_v410.z.string().min(1).optional(),
+  exit_code: import_v410.z.number().int().optional(),
+  duration_ms: import_v410.z.number().int().nonnegative().optional(),
+  run_id: import_v410.z.string().min(1).optional(),
+  stats: import_v410.z.record(import_v410.z.string(), import_v410.z.any()).optional()
 };
 
 // src/tools/listProjects.ts
 var listProjectsShape = {};
 
 // src/tools/setProject.ts
-var import_v48 = require("zod/v4");
+var import_v411 = require("zod/v4");
 var setProjectShape = {
-  projectKey: import_v48.z.string().min(1).optional(),
-  projectId: import_v48.z.string().min(1).optional()
+  projectKey: import_v411.z.string().min(1).optional(),
+  projectId: import_v411.z.string().min(1).optional()
 };
 
 // src/tools/handlers/postEvent.ts
-var import_v49 = require("zod/v4");
+var import_v412 = require("zod/v4");
 var crypto3 = __toESM(require("crypto"), 1);
 
 // src/runContext.ts
@@ -626,14 +652,14 @@ function generateRunId() {
 }
 
 // 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),
-    id: import_v49.z.string().min(1).optional()
+var postEventInputSchema = import_v412.z.object({
+  kind: import_v412.z.string().min(1),
+  actor: import_v412.z.object({
+    identifier: import_v412.z.string().min(1),
+    id: import_v412.z.string().min(1).optional()
   }),
-  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()
+  content: import_v412.z.record(import_v412.z.string(), import_v412.z.any()),
+  metadata: import_v412.z.record(import_v412.z.string(), import_v412.z.any()).optional()
 });
 async function handlePostEvent(client, args) {
   const nonce = crypto3.randomBytes(8).toString("hex");
@@ -675,14 +701,144 @@ async function handlePostEvent(client, args) {
   return { ok: true, forwarded: true };
 }
 
+// src/tools/handlers/createFact.ts
+var import_v413 = require("zod/v4");
+var createFactInputSchema = import_v413.z.object({
+  content: import_v413.z.string().min(1),
+  metadata: import_v413.z.record(import_v413.z.string(), import_v413.z.any()).optional()
+});
+async function handleCreateFact(client, args) {
+  const parsed2 = createFactInputSchema.parse(args ?? {});
+  const projectKey = getCurrentProjectId();
+  if (!projectKey) {
+    throw new Error("No project selected. Use memora_list_projects and memora_set_project to select a project.");
+  }
+  const content = parsed2.content.trim();
+  if (!content) {
+    throw new Error("content cannot be empty after trimming");
+  }
+  const { tags: userTagsRaw, ...userMetaRest } = parsed2.metadata ?? {};
+  const userTags = Array.isArray(userTagsRaw) ? userTagsRaw.filter((t) => typeof t === "string") : [];
+  const tags = ["explicit_fact", ...userTags.filter((t) => t !== "explicit_fact")];
+  const body = {
+    projectKey,
+    content,
+    metadata: {
+      ...userMetaRest,
+      source: "memoraone-mcp",
+      purpose: "explicit_fact",
+      schema: "v1",
+      tool: "memora_create_fact",
+      agent_identifier: config2.agentName,
+      tags
+    }
+  };
+  try {
+    const result = await client.post("/facts", body);
+    return { ok: true, result };
+  } catch (err) {
+    if (err instanceof MemoraOneHttpError) {
+      const bodyText = typeof err.body === "string" ? err.body : JSON.stringify(err.body ?? "");
+      throw new Error(
+        `memora_create_fact failed: ${err.status} ${err.message} ${bodyText}`.trim()
+      );
+    }
+    throw err;
+  }
+}
+
+// src/tools/handlers/addPersonalContext.ts
+var import_v414 = require("zod/v4");
+var addPersonalContextInputSchema = import_v414.z.object({
+  content: import_v414.z.string().min(1),
+  category: import_v414.z.string().optional(),
+  tags: import_v414.z.array(import_v414.z.string()).optional(),
+  scope_type: import_v414.z.enum(["general", "project"]).optional(),
+  scope_id: import_v414.z.string().optional()
+});
+async function handleAddPersonalContext(client, args) {
+  const parsed2 = addPersonalContextInputSchema.parse(args ?? {});
+  const content = parsed2.content.trim();
+  if (!content) {
+    throw new Error("content cannot be empty after trimming");
+  }
+  const body = { content };
+  if (parsed2.category !== void 0 && parsed2.category.trim() !== "") {
+    body.category = parsed2.category.trim();
+  }
+  if (parsed2.tags !== void 0 && parsed2.tags.length > 0) {
+    body.tags = parsed2.tags;
+  }
+  if (parsed2.scope_type !== void 0) {
+    body.scope_type = parsed2.scope_type;
+  }
+  if (parsed2.scope_id !== void 0 && parsed2.scope_id.trim() !== "") {
+    body.scope_id = parsed2.scope_id.trim();
+  }
+  try {
+    const result = await client.post("/v1/personal-context", body);
+    return { ok: true, result };
+  } catch (err) {
+    if (err instanceof MemoraOneHttpError) {
+      const bodyText = typeof err.body === "string" ? err.body : JSON.stringify(err.body ?? "");
+      throw new Error(
+        `memora_add_personal_context failed: ${err.status} ${err.message} ${bodyText}`.trim()
+      );
+    }
+    throw err;
+  }
+}
+
+// src/tools/handlers/getPersonalContext.ts
+var import_v415 = require("zod/v4");
+var getPersonalContextInputSchema = import_v415.z.object({
+  query: import_v415.z.string().optional(),
+  scope_type: import_v415.z.enum(["general", "project"]).optional(),
+  scope_id: import_v415.z.string().optional(),
+  limit: import_v415.z.number().int().positive().optional()
+});
+function buildPersonalContextPath(parsed2) {
+  const params = new URLSearchParams();
+  if (parsed2.query !== void 0 && parsed2.query.trim() !== "") {
+    params.set("q", parsed2.query.trim());
+  }
+  if (parsed2.scope_type !== void 0) {
+    params.set("scope_type", parsed2.scope_type);
+  }
+  if (parsed2.scope_id !== void 0 && parsed2.scope_id.trim() !== "") {
+    params.set("scope_id", parsed2.scope_id.trim());
+  }
+  if (parsed2.limit !== void 0) {
+    params.set("limit", String(parsed2.limit));
+  }
+  const qs = params.toString();
+  return qs ? `/v1/personal-context?${qs}` : "/v1/personal-context";
+}
+async function handleGetPersonalContext(client, args) {
+  const parsed2 = getPersonalContextInputSchema.parse(args ?? {});
+  const path7 = buildPersonalContextPath(parsed2);
+  try {
+    const result = await client.get(path7);
+    return { ok: true, result };
+  } catch (err) {
+    if (err instanceof MemoraOneHttpError) {
+      const bodyText = typeof err.body === "string" ? err.body : JSON.stringify(err.body ?? "");
+      throw new Error(
+        `memora_get_personal_context failed: ${err.status} ${err.message} ${bodyText}`.trim()
+      );
+    }
+    throw err;
+  }
+}
+
 // 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()
+var import_v416 = require("zod/v4");
+var askWithMemoryInputSchema = import_v416.z.object({
+  question: import_v416.z.string().min(1),
+  code_context: import_v416.z.object({
+    file_path: import_v416.z.string().optional(),
+    selected_text: import_v416.z.string().optional(),
+    language: import_v416.z.string().optional()
   }).optional()
 });
 function isAskWithMemoryResponse(value) {
@@ -715,13 +871,13 @@ async function handleAskWithMemory(client, args) {
 }
 
 // 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()
+var import_v417 = require("zod/v4");
+var logIntentInputSchema = import_v417.z.object({
+  intent: import_v417.z.enum(["task", "decision"]),
+  message: import_v417.z.string().min(1),
+  context: import_v417.z.record(import_v417.z.string(), import_v417.z.any()).optional(),
+  intent_source: import_v417.z.string().optional().default("cursor_chat"),
+  run_id: import_v417.z.string().min(1).optional()
 });
 async function handleLogIntent(client, args) {
   const parsed2 = logIntentInputSchema.parse(args ?? {});
@@ -761,18 +917,18 @@ async function handleLogIntent(client, args) {
 }
 
 // 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()
+var import_v418 = require("zod/v4");
+var logChangeSummaryInputSchema = import_v418.z.object({
+  summary: import_v418.z.string().min(1),
+  scope: import_v418.z.string().min(1).optional(),
+  files: import_v418.z.array(import_v418.z.string().min(1)).optional(),
+  stats: import_v418.z.object({
+    files: import_v418.z.number().int().nonnegative().optional(),
+    add: import_v418.z.number().int().nonnegative().optional(),
+    del: import_v418.z.number().int().nonnegative().optional()
   }).optional(),
-  commit: import_v412.z.string().min(1).optional(),
-  run_id: import_v412.z.string().min(1).optional()
+  commit: import_v418.z.string().min(1).optional(),
+  run_id: import_v418.z.string().min(1).optional()
 });
 async function handleLogChangeSummary(client, args) {
   const parsed2 = logChangeSummaryInputSchema.parse(args ?? {});
@@ -805,17 +961,17 @@ async function handleLogChangeSummary(client, args) {
 }
 
 // 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()
+var import_v419 = require("zod/v4");
+var logToolResultInputSchema = import_v419.z.object({
+  tool: import_v419.z.string().min(1),
+  status: import_v419.z.enum(["ok", "error", "partial"]),
+  summary: import_v419.z.string().min(1),
+  run_id: import_v419.z.string().min(1).optional(),
+  duration_ms: import_v419.z.number().int().nonnegative().optional(),
+  error_code: import_v419.z.string().min(1).optional(),
+  error_message: import_v419.z.string().min(1).optional(),
+  error_kind: import_v419.z.enum(["infra", "logic", "auth", "rate_limit", "validation", "unknown"]).optional(),
+  stats: import_v419.z.record(import_v419.z.string(), import_v419.z.any()).optional()
 });
 async function handleLogToolResult(client, args) {
   const parsed2 = logToolResultInputSchema.parse(args ?? {});
@@ -851,15 +1007,15 @@ async function handleLogToolResult(client, args) {
 }
 
 // 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()
+var import_v420 = require("zod/v4");
+var logCommandInputSchema = import_v420.z.object({
+  cmd: import_v420.z.string().min(1),
+  summary: import_v420.z.string().min(1),
+  cwd: import_v420.z.string().min(1).optional(),
+  exit_code: import_v420.z.number().int().optional(),
+  duration_ms: import_v420.z.number().int().nonnegative().optional(),
+  run_id: import_v420.z.string().min(1).optional(),
+  stats: import_v420.z.record(import_v420.z.string(), import_v420.z.any()).optional()
 });
 async function handleLogCommand(client, args) {
   const parsed2 = logCommandInputSchema.parse(args ?? {});
@@ -899,7 +1055,7 @@ async function handleListProjects(client) {
 }
 
 // src/tools/handlers/setProject.ts
-var import_v415 = require("zod/v4");
+var import_v421 = require("zod/v4");
 
 // src/repoFingerprint.ts
 var fs3 = __toESM(require("fs"), 1);
@@ -1228,9 +1384,9 @@ async function setProjectIdForFingerprint(args) {
 }
 
 // src/tools/handlers/setProject.ts
-var setProjectInputSchema = import_v415.z.object({
-  projectKey: import_v415.z.string().min(1).optional(),
-  projectId: import_v415.z.string().min(1).optional()
+var setProjectInputSchema = import_v421.z.object({
+  projectKey: import_v421.z.string().min(1).optional(),
+  projectId: import_v421.z.string().min(1).optional()
 });
 async function handleSetProject(args) {
   const parsed2 = setProjectInputSchema.parse(args ?? {});
@@ -1498,6 +1654,45 @@ async function main(opts = {}) {
     })
   );
   registeredToolNames.push("memora_post_event");
+  server.tool(
+    "memora_create_fact",
+    "Create an explicit project-scoped fact (POST /facts)",
+    createFactShape,
+    async (args) => runWithSessionContext(sessionContext, async () => {
+      if (!runtime.client || !runtime.projectId) return notInitializedResult;
+      const result = await handleCreateFact(runtime.client, args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    })
+  );
+  registeredToolNames.push("memora_create_fact");
+  server.tool(
+    "memora_add_personal_context",
+    "Store notes or preferences for this workspace (POST /v1/personal-context)",
+    addPersonalContextShape,
+    async (args) => runWithSessionContext(sessionContext, async () => {
+      if (!runtime.client || !runtime.projectId) return notInitializedResult;
+      const result = await handleAddPersonalContext(runtime.client, args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    })
+  );
+  registeredToolNames.push("memora_add_personal_context");
+  server.tool(
+    "memora_get_personal_context",
+    "Search stored notes or preferences for this workspace (GET /v1/personal-context)",
+    getPersonalContextShape,
+    async (args) => runWithSessionContext(sessionContext, async () => {
+      if (!runtime.client || !runtime.projectId) return notInitializedResult;
+      const result = await handleGetPersonalContext(runtime.client, args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    })
+  );
+  registeredToolNames.push("memora_get_personal_context");
   server.tool(
     "memora_list_projects",
     "List projects available to the current API key",
@@ -1529,7 +1724,7 @@ async function main(opts = {}) {
     runtime,
     sessionContext,
     "memora_ask_with_memory",
-    "Ask MemoraOne with project memory context",
+    "Answer using saved workspace knowledge and timeline. In user-visible replies, state facts directly; do not attribute answers to tools, storage, retrieval, or memory-style framing unless the user asks how you know.",
     askWithMemoryShape,
     async (args) => {
       const result = await handleAskWithMemory(runtime.client, args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memoraone/mcp",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "type": "module",
   "main": "dist/index.cjs",
   "bin": {