@memoraone/mcp 0.1.18 → 0.1.20

package/dist/cli.cjs

@@ -30,7 +30,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@memoraone/mcp",
-      version: "0.1.18",
+      version: "0.1.20",
       type: "module",
       main: "dist/index.cjs",
       bin: {
@@ -67,7 +67,7 @@ var require_package = __commonJS({
 });
 
 // src/cli.ts
-var path3 = __toESM(require("path"), 1);
+var path4 = __toESM(require("path"), 1);
 var net = __toESM(require("net"), 1);
 var import_node_child_process = require("child_process");
 
@@ -219,6 +219,270 @@ function encodeResolvedBinding(binding) {
   return Buffer.from(JSON.stringify(binding), "utf8").toString("base64");
 }
 
+// src/setupIdeFiles.ts
+var fs3 = __toESM(require("fs/promises"), 1);
+var path3 = __toESM(require("path"), 1);
+var MANAGED_MARKER = "<!-- MemoraOne managed IDE helper -->";
+var MEMORAONE_MCP_SERVER = {
+  command: "npx",
+  args: ["-y", "@memoraone/mcp"]
+};
+function assertUnderRepoRoot(repoRoot, absPath) {
+  const normRoot = path3.resolve(repoRoot) + path3.sep;
+  const normPath = path3.resolve(absPath);
+  if (normPath !== path3.resolve(repoRoot) && !normPath.startsWith(normRoot)) {
+    throw new Error(`[setup-ide-files] Refusing to write outside repo root: ${absPath}`);
+  }
+}
+async function pathExists(filePath) {
+  try {
+    await fs3.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findRepoRoot(startDir) {
+  let current = path3.resolve(startDir);
+  const root = path3.parse(current).root;
+  while (true) {
+    const gitPath = path3.join(current, ".git");
+    const m1Path = path3.join(current, "memoraone.m1");
+    if (await pathExists(gitPath) || await pathExists(m1Path)) {
+      return current;
+    }
+    if (current === root) {
+      return null;
+    }
+    current = path3.dirname(current);
+  }
+}
+function stripLeadingLineComments(text) {
+  return text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
+}
+function cursorRuleBody() {
+  return `${MANAGED_MARKER}
+
+## MemoraOne MCP (IDE agent only)
+
+This repository uses **MemoraOne** via the MCP server named **user-memoraone** (Cursor MCP configuration). This guidance applies to the **IDE coding agent** only \u2014 not the MemoraOne Studio runtime path.
+
+### Tools
+
+- Before answering questions about **prior decisions**, **remembered facts**, **identity or personal recall**, **preferences**, **repo history**, or **what to do next**, call **\`memora_ask_with_memory\`** so replies stay aligned with MemoraOne memory.
+- After **meaningful repository changes** (decisions, fixes, new endpoints or schema, migrations, meaningful wiring), call **\`memora_post_event\`** to append a concise timeline note.
+
+Keep tool usage proportional to the task; do not spam events for trivial edits.
+`;
+}
+function copilotAndJetBrainsBody(title) {
+  return `${MANAGED_MARKER}
+
+# ${title}
+
+This repo is set up to use **MemoraOne** through MCP where your editor exposes it. These instructions apply to the **IDE assistant** in this workspace, not to other MemoraOne runtimes.
+
+## Behavior
+
+- For questions about **earlier decisions**, **stored facts**, **personal or identity recall**, **preferences**, **project history**, or **recommended next steps**, use MemoraOne memory tools (e.g. **\`memora_ask_with_memory\`**) when available before answering.
+- After **substantive changes** to this codebase (feature work, bugfixes, API/schema changes, migrations, meaningful integration steps), record a short timeline note with **\`memora_post_event\`** when that tool is available.
+
+Use judgment: skip logging for trivial typo-only edits.
+`;
+}
+function mcpJsonHeader() {
+  return `// ${MANAGED_MARKER}
+`;
+}
+function buildMcpJsonBody(existing) {
+  const base = existing && typeof existing === "object" ? { ...existing } : { mcpServers: {} };
+  const servers = typeof base.mcpServers === "object" && base.mcpServers !== null && !Array.isArray(base.mcpServers) ? { ...base.mcpServers } : {};
+  servers.memoraone = { ...MEMORAONE_MCP_SERVER };
+  const merged = { ...base, mcpServers: servers };
+  return mcpJsonHeader() + JSON.stringify(merged, null, 2) + "\n";
+}
+async function writeManagedMarkdown(repoRoot, relPath, fullContent, opts) {
+  const abs = path3.join(repoRoot, relPath);
+  assertUnderRepoRoot(repoRoot, abs);
+  let prior = "";
+  let existed = false;
+  try {
+    prior = await fs3.readFile(abs, "utf8");
+    existed = true;
+  } catch (err) {
+    if (err?.code !== "ENOENT") throw err;
+  }
+  if (!existed) {
+    if (opts.dryRun) return "created";
+    await fs3.mkdir(path3.dirname(abs), { recursive: true });
+    await fs3.writeFile(abs, fullContent, "utf8");
+    return "created";
+  }
+  if (prior.includes(MANAGED_MARKER)) {
+    if (prior === fullContent) return "skipped";
+    if (opts.dryRun) return "updated";
+    await fs3.mkdir(path3.dirname(abs), { recursive: true });
+    await fs3.writeFile(abs, fullContent, "utf8");
+    return "updated";
+  }
+  if (!opts.force) return "skipped-untracked";
+  if (opts.dryRun) return "updated";
+  await fs3.mkdir(path3.dirname(abs), { recursive: true });
+  await fs3.writeFile(abs, fullContent, "utf8");
+  return "updated";
+}
+async function writeMcpJson(repoRoot, opts) {
+  const abs = path3.join(repoRoot, ".vscode/mcp.json");
+  assertUnderRepoRoot(repoRoot, abs);
+  let raw = "";
+  let existed = false;
+  try {
+    raw = await fs3.readFile(abs, "utf8");
+    existed = true;
+  } catch (err) {
+    if (err?.code !== "ENOENT") throw err;
+  }
+  if (!existed) {
+    const body = buildMcpJsonBody(null);
+    if (opts.dryRun) return "created";
+    await fs3.mkdir(path3.dirname(abs), { recursive: true });
+    await fs3.writeFile(abs, body, "utf8");
+    return "created";
+  }
+  const managed = raw.includes(MANAGED_MARKER);
+  if (!managed && !opts.force) return "skipped-untracked";
+  let parsed = null;
+  try {
+    parsed = JSON.parse(stripLeadingLineComments(raw));
+  } catch {
+    parsed = null;
+  }
+  if (!parsed && !opts.force) return "skipped-untracked";
+  const next = buildMcpJsonBody(parsed);
+  if (managed && next === raw) return "skipped";
+  if (opts.dryRun) return "updated";
+  await fs3.mkdir(path3.dirname(abs), { recursive: true });
+  await fs3.writeFile(abs, next, "utf8");
+  return "updated";
+}
+function parseSetupIdeFlags(argv) {
+  let cursor = false;
+  let vscode = false;
+  let jetbrains = false;
+  let all = false;
+  let force = false;
+  let dryRun = false;
+  const unknown = [];
+  for (const a of argv) {
+    if (a === "--cursor") cursor = true;
+    else if (a === "--vscode") vscode = true;
+    else if (a === "--jetbrains") jetbrains = true;
+    else if (a === "--all") all = true;
+    else if (a === "--force") force = true;
+    else if (a === "--dry-run") dryRun = true;
+    else if (a.startsWith("-")) unknown.push(a);
+  }
+  const specific = cursor || vscode || jetbrains;
+  let targets;
+  if (all || !specific) {
+    targets = { cursor: true, vscode: true, jetbrains: true };
+  } else {
+    targets = { cursor, vscode, jetbrains };
+  }
+  return { targets, force, dryRun, unknown };
+}
+function summarizeOutcomes(outcomes) {
+  const created = [];
+  const updated = [];
+  const skipped = [];
+  const skippedUntracked = [];
+  for (const [file, o] of Object.entries(outcomes)) {
+    if (o === "created") created.push(file);
+    else if (o === "updated") updated.push(file);
+    else if (o === "skipped") skipped.push(file);
+    else skippedUntracked.push(file);
+  }
+  const lines = ["[setup-ide-files] Summary"];
+  if (created.length) lines.push(`  created: ${created.join(", ")}`);
+  if (updated.length) lines.push(`  updated: ${updated.join(", ")}`);
+  if (skipped.length) lines.push(`  skipped (unchanged): ${skipped.join(", ")}`);
+  if (skippedUntracked.length) {
+    lines.push(`  skipped (unmanaged existing file, use --force): ${skippedUntracked.join(", ")}`);
+  }
+  console.log(lines.join("\n"));
+}
+async function runSetupIdeFiles(o) {
+  const outcomes = {};
+  const repoRoot = await findRepoRoot(o.cwd);
+  if (!repoRoot) {
+    return {
+      exitCode: 1,
+      repoRoot: null,
+      outcomes,
+      error: "[setup-ide-files] No repo root found (looked for .git or memoraone.m1)."
+    };
+  }
+  const cursorContent = `---
+description: MemoraOne MCP \u2014 IDE agent instructions
+---
+
+` + cursorRuleBody();
+  if (o.targets.cursor) {
+    outcomes[".cursor/rules/memoraone-mcp.mdc"] = await writeManagedMarkdown(
+      repoRoot,
+      ".cursor/rules/memoraone-mcp.mdc",
+      cursorContent,
+      { force: o.force, dryRun: o.dryRun }
+    );
+  }
+  if (o.targets.vscode) {
+    outcomes[".vscode/mcp.json"] = await writeMcpJson(repoRoot, {
+      force: o.force,
+      dryRun: o.dryRun
+    });
+    outcomes[".github/copilot-instructions.md"] = await writeManagedMarkdown(
+      repoRoot,
+      ".github/copilot-instructions.md",
+      copilotAndJetBrainsBody("MemoraOne MCP \u2014 GitHub Copilot"),
+      { force: o.force, dryRun: o.dryRun }
+    );
+  }
+  if (o.targets.jetbrains) {
+    outcomes[".aiassistant/rules/memoraone.md"] = await writeManagedMarkdown(
+      repoRoot,
+      ".aiassistant/rules/memoraone.md",
+      copilotAndJetBrainsBody("MemoraOne MCP \u2014 JetBrains AI Assistant"),
+      { force: o.force, dryRun: o.dryRun }
+    );
+  }
+  return { exitCode: 0, repoRoot, outcomes };
+}
+async function cliSetupIdeFiles(argv) {
+  const { targets, force, dryRun, unknown } = parseSetupIdeFlags(argv);
+  if (unknown.length) {
+    console.error(`[setup-ide-files] Unknown option(s): ${unknown.join(", ")}`);
+    return 1;
+  }
+  const result = await runSetupIdeFiles({
+    cwd: process.cwd(),
+    targets,
+    force,
+    dryRun
+  });
+  if (result.error) {
+    console.error(result.error);
+    return result.exitCode;
+  }
+  if (result.repoRoot) {
+    console.log(`[setup-ide-files] Repo root: ${result.repoRoot}`);
+  }
+  summarizeOutcomes(result.outcomes);
+  if (dryRun) {
+    console.log("[setup-ide-files] Dry run: no files written.");
+  }
+  return 0;
+}
+
 // src/cli.ts
 var { version } = require_package();
 var args = process.argv.slice(2);
@@ -227,10 +491,18 @@ if (args.includes("--version") || args.includes("-v")) {
   process.exit(0);
 }
 if (args.includes("--help") || args.includes("-h")) {
-  console.log("Usage: memoraone-mcp [--version] [--help] [--daemon --project-id <uuid>]");
+  console.log(
+    "Usage: memoraone-mcp [--version] [--help] [--daemon --project-id <uuid>]\n       memoraone-mcp setup-ide-files [--all|--cursor|--vscode|--jetbrains] [--force] [--dry-run]"
+  );
   process.exit(0);
 }
-if (args.includes("--daemon")) {
+if (args[0] === "setup-ide-files") {
+  cliSetupIdeFiles(args.slice(1)).then((code) => process.exit(code)).catch((err) => {
+    process.stderr.write(`[memoraone-mcp] setup-ide-files fatal: ${String(err)}
+`);
+    process.exit(1);
+  });
+} else if (args.includes("--daemon")) {
   import("./daemon.cjs").then(({ runDaemon }) => runDaemon()).catch((err) => {
     process.stderr.write(`[memoraone-mcp] daemon fatal: ${String(err)}
 `);
@@ -241,8 +513,8 @@ if (args.includes("--daemon")) {
     const raw = process.env.WORKSPACE_FOLDER_PATHS;
     const parts = [];
     if (raw !== void 0 && raw.trim() !== "") {
-      for (const p of raw.split(path3.delimiter).map((s) => s.trim()).filter(Boolean)) {
-        parts.push(path3.resolve(p));
+      for (const p of raw.split(path4.delimiter).map((s) => s.trim()).filter(Boolean)) {
+        parts.push(path4.resolve(p));
       }
     }
     parts.push(process.cwd());
@@ -256,10 +528,10 @@ if (args.includes("--daemon")) {
     }
     return deduped;
   }, connectWithRetry = function(socketPath) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const tryConnect = (attempt) => {
         const socket = net.connect(socketPath, () => {
-          resolve3(socket);
+          resolve4(socket);
         });
         socket.on("error", (err) => {
           if (attempt >= MAX_RETRIES) {
@@ -308,12 +580,6 @@ if (args.includes("--daemon")) {
     }
     log("bridge connected");
     log("forwarding active");
-    process.stdin.on("data", (chunk) => {
-      const text = chunk.toString("utf8");
-      const hasToolsCall = text.includes('"tools/call"') || text.includes("tools/call");
-      const hasInitialize = text.includes('"initialize"');
-      log(`[stdin-diagnostic] bytes=${chunk.length} tools/call=${hasToolsCall} initialize=${hasInitialize}`);
-    });
     process.stdin.pipe(socket);
     socket.pipe(process.stdout);
     socket.on("close", () => process.exit(0));