@sksoftofficial/mindroot 1.0.5 → 1.1.0

package/test/install-clients.test.js

@@ -0,0 +1,187 @@
+import { test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { parse as parseToml } from "@decimalturn/toml-patch";
+import { configureClaude, configureCodex } from "../src/commands/install.js";
+
+let dir;
+const cfg = { port: 8765, apiKey: "test-only-key" };
+const policy = (await fs.readFile(new URL("../INSTRUCTIONS.md", import.meta.url), "utf8")).trim();
+const savedEnv = {};
+
+beforeEach(async () => {
+  dir = await fs.mkdtemp(path.join(os.tmpdir(), "mindroot-install-clients-"));
+  for (const name of ["CLAUDE_CONFIG_DIR", "CODEX_HOME"]) {
+    savedEnv[name] = process.env[name];
+    delete process.env[name];
+  }
+});
+
+afterEach(async () => {
+  for (const [name, value] of Object.entries(savedEnv)) {
+    if (value === undefined) delete process.env[name];
+    else process.env[name] = value;
+  }
+  await fs.rm(dir, { recursive: true, force: true });
+});
+
+test("claude: defaults keep .claude.json outside ~/.claude; a rerun is byte-identical", async (t) => {
+  const home = path.join(dir, "home");
+  t.mock.method(os, "homedir", () => home);
+  const { configPath, agentsPath } = configureClaude(cfg);
+  assert.equal(configPath, path.join(home, ".claude.json"));
+  assert.equal(agentsPath, path.join(home, ".claude", "CLAUDE.md"));
+  const configText = await fs.readFile(configPath, "utf8");
+  assert.deepEqual(JSON.parse(configText), {
+    mcpServers: { mindroot: {
+      type: "http", url: "http://127.0.0.1:8765/mcp",
+      headers: { Authorization: "Bearer test-only-key" },
+    } },
+  });
+  assert.equal(await fs.readFile(agentsPath, "utf8"), policy + "\n");
+  configureClaude(cfg);
+  assert.equal(await fs.readFile(configPath, "utf8"), configText);
+  assert.equal(await fs.readFile(agentsPath, "utf8"), policy + "\n");
+  if (process.platform !== "win32") assert.equal((await fs.stat(configPath)).mode & 0o777, 0o600);
+});
+
+test("claude: explicit directories and CLAUDE_CONFIG_DIR keep both files inside", async () => {
+  const explicit = configureClaude(cfg, path.join(dir, "explicit"));
+  assert.equal(explicit.configPath, path.join(dir, "explicit", ".claude.json"));
+  assert.equal(explicit.agentsPath, path.join(dir, "explicit", "CLAUDE.md"));
+  process.env.CLAUDE_CONFIG_DIR = path.join(dir, "envdir");
+  const env = configureClaude(cfg);
+  assert.equal(env.configPath, path.join(dir, "envdir", ".claude.json"));
+  assert.equal(env.agentsPath, path.join(dir, "envdir", "CLAUDE.md"));
+});
+
+test("claude: preserves unrelated settings and refreshes the owned entry", async () => {
+  const configPath = path.join(dir, ".claude.json");
+  await fs.writeFile(configPath, JSON.stringify({
+    model: "claude-opus",
+    mcpServers: { other: { type: "stdio", command: ["x"] }, mindroot: { type: "sse", url: "stale" } },
+    projects: { "/work": { allowed: true } },
+  }));
+  configureClaude(cfg, dir);
+  const config = JSON.parse(await fs.readFile(configPath, "utf8"));
+  assert.equal(config.model, "claude-opus");
+  assert.deepEqual(config.projects, { "/work": { allowed: true } });
+  assert.deepEqual(config.mcpServers.other, { type: "stdio", command: ["x"] });
+  assert.deepEqual(config.mcpServers.mindroot, {
+    type: "http", url: "http://127.0.0.1:8765/mcp",
+    headers: { Authorization: "Bearer test-only-key" },
+  });
+  configureClaude({ port: 9876, apiKey: "replacement-test-key" }, dir);
+  const updated = JSON.parse(await fs.readFile(configPath, "utf8")).mcpServers.mindroot;
+  assert.equal(updated.url, "http://127.0.0.1:9876/mcp");
+  assert.equal(updated.headers.Authorization, "Bearer replacement-test-key");
+});
+
+test("claude: malformed config or markers leave both files untouched", async () => {
+  const configPath = path.join(dir, ".claude.json");
+  const agentsPath = path.join(dir, "CLAUDE.md");
+  const cases = [
+    ["{ broken", "Keep me", /invalid Claude configuration/],
+    ["[1]", "Keep me", /invalid Claude configuration/],
+    ['{"mcpServers": []}', "Keep me", /expected an mcpServers object/],
+    ["{}", "<!-- mindroot:start -->\nunfinished", /unbalanced mindroot markers/],
+  ];
+  for (const [config, agents, error] of cases) {
+    await fs.writeFile(configPath, config);
+    await fs.writeFile(agentsPath, agents);
+    assert.throws(() => configureClaude(cfg, dir), error);
+    assert.equal(await fs.readFile(configPath, "utf8"), config);
+    assert.equal(await fs.readFile(agentsPath, "utf8"), agents);
+  }
+});
+
+test("codex: creates config and policy, preserves TOML comments; a rerun is byte-identical", async () => {
+  const configPath = path.join(dir, "config.toml");
+  await fs.writeFile(configPath, `# Codex config
+model = "gpt-5-codex"
+
+[mcp_servers.other]
+url = "https://example.com/mcp" # keep me
+`);
+  const { configPath: returned, agentsPath } = configureCodex(cfg, dir);
+  assert.equal(returned, configPath);
+  assert.equal(agentsPath, path.join(dir, "AGENTS.md"));
+  const first = await fs.readFile(configPath, "utf8");
+  assert.ok(first.includes("# Codex config"));
+  assert.ok(first.includes('model = "gpt-5-codex"'));
+  assert.ok(first.includes('url = "https://example.com/mcp" # keep me'));
+  const config = parseToml(first);
+  assert.deepEqual(config.mcp_servers.mindroot, {
+    url: "http://127.0.0.1:8765/mcp",
+    http_headers: { Authorization: "Bearer test-only-key" },
+  });
+  assert.equal(config.model, "gpt-5-codex");
+  assert.equal(await fs.readFile(agentsPath, "utf8"), policy + "\n");
+  configureCodex(cfg, dir);
+  assert.equal(await fs.readFile(configPath, "utf8"), first);
+  assert.equal(await fs.readFile(agentsPath, "utf8"), policy + "\n");
+  if (process.platform !== "win32") assert.equal((await fs.stat(configPath)).mode & 0o777, 0o600);
+});
+
+test("codex: honors CODEX_HOME or ~/.codex by default and refreshes the owned entry", async (t) => {
+  const home = path.join(dir, "home");
+  t.mock.method(os, "homedir", () => home);
+  const defaulted = configureCodex(cfg);
+  assert.equal(defaulted.configPath, path.join(home, ".codex", "config.toml"));
+  assert.equal(defaulted.agentsPath, path.join(home, ".codex", "AGENTS.md"));
+  process.env.CODEX_HOME = path.join(dir, "custom");
+  const env = configureCodex({ port: 9876, apiKey: "replacement-test-key" });
+  assert.equal(env.configPath, path.join(dir, "custom", "config.toml"));
+  const config = parseToml(await fs.readFile(env.configPath, "utf8"));
+  assert.equal(config.mcp_servers.mindroot.url, "http://127.0.0.1:9876/mcp");
+  assert.equal(config.mcp_servers.mindroot.http_headers.Authorization, "Bearer replacement-test-key");
+});
+
+test("codex: syncs a non-empty AGENTS.override.md; an empty override falls back to AGENTS.md", async () => {
+  const basePath = path.join(dir, "AGENTS.md");
+  const overridePath = path.join(dir, "AGENTS.override.md");
+  await fs.writeFile(basePath, "# Base\nKeep me.\n");
+  await fs.writeFile(overridePath, "Override content.\n");
+  const active = configureCodex(cfg, dir);
+  assert.equal(active.agentsPath, overridePath);
+  assert.equal(await fs.readFile(overridePath, "utf8"), "Override content.\n\n" + policy + "\n");
+  assert.equal(await fs.readFile(basePath, "utf8"), "# Base\nKeep me.\n");
+
+  await fs.writeFile(overridePath, "\n");
+  const fallback = configureCodex(cfg, dir);
+  assert.equal(fallback.agentsPath, basePath);
+  assert.equal(await fs.readFile(overridePath, "utf8"), "\n");
+  assert.equal(await fs.readFile(basePath, "utf8"), "# Base\nKeep me.\n\n" + policy + "\n");
+});
+
+test("codex: malformed TOML, bad shapes, or markers leave both files untouched", async () => {
+  const configPath = path.join(dir, "config.toml");
+  const agentsPath = path.join(dir, "AGENTS.md");
+  const cases = [
+    ["model = ", "Keep me", /invalid Codex configuration/],
+    ["mcp_servers = 3", "Keep me", /expected an mcp_servers table/],
+    ["mcp_servers.mindroot = 5", "Keep me", /expected mcp_servers\.mindroot to be a table/],
+    ["", "<!-- mindroot:end -->", /unbalanced mindroot markers/],
+  ];
+  for (const [config, agents, error] of cases) {
+    await fs.writeFile(configPath, config);
+    await fs.writeFile(agentsPath, agents);
+    assert.throws(() => configureCodex(cfg, dir), error);
+    assert.equal(await fs.readFile(configPath, "utf8"), config);
+    assert.equal(await fs.readFile(agentsPath, "utf8"), agents);
+  }
+});
+
+test("both clients replace marked policies and preserve surrounding instructions", async () => {
+  const prefix = "# User instructions\nKeep these.\n\n";
+  const suffix = "\nCustom footer without a trailing newline";
+  const old = "<!-- mindroot:start -->\nOld policy\n<!-- mindroot:end -->";
+  for (const configure of [(d) => configureClaude(cfg, d), (d) => configureCodex(cfg, d)]) {
+    const agentsPath = path.join(dir, "AGENTS.md");
+    await fs.writeFile(agentsPath, prefix + old + suffix);
+    configure(dir);
+    assert.equal(await fs.readFile(agentsPath, "utf8"), prefix + policy + suffix);
+  }
+});

package/test/install.test.js

@@ -0,0 +1,127 @@
+import { test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { parse } from "jsonc-parser";
+import { configureOpencode, install } from "../src/commands/install.js";
+
+let dir;
+const cfg = { port: 8765, apiKey: "test-only-key" };
+const policy = (await fs.readFile(new URL("../INSTRUCTIONS.md", import.meta.url), "utf8")).trim();
+beforeEach(async () => { dir = await fs.mkdtemp(path.join(os.tmpdir(), "mindroot-install-")); });
+afterEach(() => fs.rm(dir, { recursive: true, force: true }));
+
+test("creates global config and policy; a rerun is byte-identical", async () => {
+  const configDir = path.join(dir, "opencode");
+  const { configPath, agentsPath } = configureOpencode(cfg, configDir);
+  const configText = await fs.readFile(configPath, "utf8");
+  assert.deepEqual(JSON.parse(configText), {
+    $schema: "https://opencode.ai/config.json",
+    mcp: { mindroot: {
+      type: "remote", url: "http://127.0.0.1:8765/mcp", enabled: true,
+      headers: { Authorization: "Bearer test-only-key" },
+    } },
+  });
+  assert.equal(await fs.readFile(agentsPath, "utf8"), policy + "\n");
+  configureOpencode(cfg, configDir);
+  assert.equal(await fs.readFile(configPath, "utf8"), configText);
+  assert.equal(await fs.readFile(agentsPath, "utf8"), policy + "\n");
+  if (process.platform !== "win32") assert.equal((await fs.stat(configPath)).mode & 0o777, 0o600);
+});
+
+test("refreshes the owned MCP entry while preserving JSONC and unrelated settings", async () => {
+  const jsonPath = path.join(dir, "opencode.json");
+  const jsoncPath = path.join(dir, "opencode.jsonc");
+  const json = '{"model":"keep/this"}\n';
+  await fs.writeFile(jsonPath, json);
+  await fs.writeFile(jsoncPath, `{
+  // Keep this comment and setting.
+  "model": "provider/model",
+  "mcp": {
+    // Another server stays untouched.
+    "other": { "type": "local", "command": ["other-mcp"] },
+    "mindroot": { "type": "local", "command": ["old"], "enabled": false },
+  },
+}\n`);
+  const { configPath } = configureOpencode(cfg, dir);
+  assert.equal(configPath, jsoncPath);
+  assert.equal(await fs.readFile(jsonPath, "utf8"), json);
+  const text = await fs.readFile(jsoncPath, "utf8");
+  assert.ok(text.includes("// Keep this comment and setting."));
+  assert.ok(text.includes('// Another server stays untouched.\n    "other": { "type": "local", "command": ["other-mcp"] },'));
+  const config = parse(text);
+  assert.equal(config.model, "provider/model");
+  assert.equal(config.mcp.mindroot.command, undefined);
+  assert.equal(config.mcp.mindroot.enabled, true);
+  configureOpencode({ port: 9876, apiKey: "replacement-test-key" }, dir);
+  const updated = parse(await fs.readFile(jsoncPath, "utf8")).mcp.mindroot;
+  assert.equal(updated.url, "http://127.0.0.1:9876/mcp");
+  assert.equal(updated.headers.Authorization, "Bearer replacement-test-key");
+});
+
+test("replaces marked policies, removes duplicates, and preserves surrounding instructions", async () => {
+  const agentsPath = path.join(dir, "AGENTS.md");
+  const old = "<!-- mindroot:start -->\nOld policy\n<!-- mindroot:end -->";
+  const prefix = "# User instructions\nKeep these.\n\n";
+  const middle = "\n\n<!-- another:start -->\nOther policy\n<!-- another:end -->\n";
+  const suffix = "\nCustom footer without a trailing newline";
+  await fs.writeFile(agentsPath, prefix + old + middle + old + suffix);
+  configureOpencode(cfg, dir);
+  const expected = prefix + policy + middle + suffix;
+  assert.equal(await fs.readFile(agentsPath, "utf8"), expected);
+  configureOpencode(cfg, dir);
+  assert.equal(await fs.readFile(agentsPath, "utf8"), expected);
+});
+
+test("appends a separated policy when no marked block exists", async () => {
+  const agentsPath = path.join(dir, "AGENTS.md");
+  for (const existing of ["", "Keep me", "Keep me\n", "Keep me\n\n"]) {
+    await fs.writeFile(agentsPath, existing);
+    configureOpencode(cfg, dir);
+    assert.equal(await fs.readFile(agentsPath, "utf8"), (existing ? "Keep me\n\n" : "") + policy + "\n");
+  }
+});
+
+test("malformed config or markers leave both files untouched", async () => {
+  const configPath = path.join(dir, "opencode.json");
+  const agentsPath = path.join(dir, "AGENTS.md");
+  const cases = [
+    ["{ broken", "Keep me", /invalid OpenCode configuration/],
+    ["[]", "Keep me", /invalid OpenCode configuration/],
+    ['{"mcp": []}', "Keep me", /expected an mcp object/],
+    ['{"mcp": null}', "Keep me", /expected an mcp object/],
+    ["{}", "<!-- mindroot:start -->\nunfinished", /unbalanced mindroot markers/],
+    ["{}", "<!-- mindroot:end -->", /unbalanced mindroot markers/],
+    ["{}", "<!-- mindroot:start --><!-- mindroot:start --><!-- mindroot:end --><!-- mindroot:end -->", /unbalanced mindroot markers/],
+  ];
+  for (const [config, agents, error] of cases) {
+    await fs.writeFile(configPath, config);
+    await fs.writeFile(agentsPath, agents);
+    assert.throws(() => configureOpencode(cfg, dir), error);
+    assert.equal(await fs.readFile(configPath, "utf8"), config);
+    assert.equal(await fs.readFile(agentsPath, "utf8"), agents);
+  }
+});
+
+test("respects XDG_CONFIG_HOME and the explicit OpenCode directory override", (t) => {
+  const previous = { XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME, OPENCODE_CONFIG_DIR: process.env.OPENCODE_CONFIG_DIR };
+  t.after(() => {
+    for (const [name, value] of Object.entries(previous)) {
+      if (value === undefined) delete process.env[name];
+      else process.env[name] = value;
+    }
+  });
+  process.env.XDG_CONFIG_HOME = dir;
+  delete process.env.OPENCODE_CONFIG_DIR;
+  assert.equal(configureOpencode(cfg).configPath, path.join(dir, "opencode", "opencode.json"));
+  const custom = path.join(dir, "custom");
+  process.env.OPENCODE_CONFIG_DIR = custom;
+  assert.equal(configureOpencode(cfg).agentsPath, path.join(custom, "AGENTS.md"));
+});
+
+test("rejects missing or unsupported install targets before initialization", async () => {
+  for (const args of [[], ["unknown"], ["opencode", "extra"], ["claude", "codex"]]) {
+    await assert.rejects(install(args), /usage: mindroot install <opencode\|claude\|codex>/);
+  }
+});

package/test/mcp.test.js

@@ -10,18 +10,22 @@ let db;
 let open;
 
 const EXPECTED_TOOLS = [
-  "mindroot_list_projects",
-  "mindroot_search_projects",
-  "mindroot_rename_project",
-  "mindroot_search_memories",
-  "mindroot_search_notes",
-  "mindroot_save_memory",
-  "mindroot_delete_memory",
-  "mindroot_list_notes",
-  "mindroot_read_note",
-  "mindroot_save_note",
-  "mindroot_update_section",
-  "mindroot_delete_note",
+  "list_projects",
+  "search_projects",
+  "rename_project",
+  "search_memories",
+  "search_notes",
+  "save_memory",
+  "delete_memory",
+  "list_notes",
+  "read_note",
+  "save_note",
+  "update_section",
+  "delete_note",
+  "search_skills",
+  "read_skill",
+  "save_skill",
+  "delete_skill",
 ];
 
 before(async () => {
@@ -58,19 +62,19 @@ test("unknown tool returns clean error", async () => {
 });
 
 test("search without project is a clean isError", async () => {
-  const res = await call("mindroot_search_memories", { query: "x" });
+  const res = await call("search_memories", { query: "x" });
   assert.equal(res.body.result.isError, true);
   assert.match(res.body.result.content[0].text, /project is required/);
 });
 
 test("invalid slug is rejected before any lookup", async () => {
-  const res = await call("mindroot_search_memories", { project: "../evil", query: "x" });
+  const res = await call("search_memories", { project: "../evil", query: "x" });
   assert.equal(res.body.result.isError, true);
   assert.match(res.body.result.content[0].text, /invalid project slug/);
 });
 
 test("unknown project is a clean error", async () => {
-  const res = await call("mindroot_search_memories", { project: "ghost", query: "x" });
+  const res = await call("search_memories", { project: "ghost", query: "x" });
   assert.match(res.body.result.content[0].text, /unknown project: ghost/);
 });
 
@@ -89,35 +93,35 @@ test("rename_project moves slug, dir, and embeddings", async () => {
   fs.mkdirSync(path.join(NOTES_DIR, "old-name"), { recursive: true });
   fs.writeFileSync(path.join(NOTES_DIR, "old-name", "overview.md"), "# Old\n");
 
-  const res = await call("mindroot_rename_project", { project: "old-name", new_slug: "new-name" });
+  const res = await call("rename_project", { project: "old-name", new_slug: "new-name" });
   const data = JSON.parse(res.body.result.content[0].text);
   assert.deepEqual(data.renamed, { from: "old-name", to: "new-name" });
   assert.equal(db.prepare("SELECT slug FROM projects WHERE id = ?").get(pid).slug, "new-name");
   assert.ok(fs.existsSync(path.join(NOTES_DIR, "new-name", "overview.md")));
   assert.ok(!fs.existsSync(path.join(NOTES_DIR, "old-name")));
   assert.equal(db.prepare("SELECT COUNT(*) n FROM project_embeddings WHERE project_id = ?").get(pid).n, 0);
-  const listed = JSON.parse((await call("mindroot_list_projects", {})).body.result.content[0].text);
+  const listed = JSON.parse((await call("list_projects", {})).body.result.content[0].text);
   const row = listed.find((p) => p.slug === "new-name");
   assert.equal(row.memories, 1);
   assert.ok(!listed.some((p) => p.slug === "old-name"));
 
-  const dup = await call("mindroot_rename_project", { project: "new-name", new_slug: "new-name" });
+  const dup = await call("rename_project", { project: "new-name", new_slug: "new-name" });
   assert.equal(dup.body.result.isError, true);
   assert.match(dup.body.result.content[0].text, /already named/);
 
-  const bad = await call("mindroot_rename_project", { project: "new-name", new_slug: "../evil" });
+  const bad = await call("rename_project", { project: "new-name", new_slug: "../evil" });
   assert.equal(bad.body.result.isError, true);
   assert.match(bad.body.result.content[0].text, /invalid project slug/);
 });
 
 test("update_section appends a missing section", async () => {
-  await call("mindroot_save_note", {
+  await call("save_note", {
     project: "section-upsert",
     path: "note.md",
     content: "# Note\n\n## Existing\n\nkeep me\n",
   });
 
-  const res = await call("mindroot_update_section", {
+  const res = await call("update_section", {
     project: "section-upsert",
     path: "note.md",
     heading_path: "Added",

package/test/paths.test.js

@@ -0,0 +1,53 @@
+import { test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+let dir;
+let paths;
+beforeEach(async () => {
+  dir = await fs.mkdtemp(path.join(os.tmpdir(), "mindroot-paths-"));
+  process.env.MINDROOT_DIR = dir;
+  paths = await import("../src/paths.js");
+});
+afterEach(async () => {
+  delete process.env.MINDROOT_DIR;
+  await fs.rm(dir, { recursive: true, force: true });
+});
+
+test("ensureConfig generates the key once and keeps it stable across runs", async () => {
+  const first = paths.ensureConfig();
+  assert.equal(first.created, true);
+  assert.ok(first.cfg.apiKey);
+  const second = paths.ensureConfig();
+  assert.equal(second.created, false);
+  assert.equal(second.cfg.apiKey, first.cfg.apiKey);
+  assert.equal(second.cfg.port, paths.DEFAULT_PORT);
+  if (process.platform !== "win32") {
+    assert.equal((await fs.stat(path.join(dir, "config.json"))).mode & 0o777, 0o600);
+  }
+});
+
+test("ensureConfig keeps a stored key and port", async () => {
+  await fs.writeFile(path.join(dir, "config.json"), JSON.stringify({ apiKey: "keep-me", port: 9999 }));
+  const { cfg, created } = paths.ensureConfig();
+  assert.equal(created, false);
+  assert.equal(cfg.apiKey, "keep-me");
+  assert.equal(cfg.port, 9999);
+});
+
+test("missing config reads as empty without creating one", () => {
+  const { cfg, created } = paths.ensureConfig();
+  assert.equal(created, true);
+  assert.ok(cfg.apiKey);
+});
+
+test("corrupt or non-object configs fail loudly instead of rotating the key", async () => {
+  const configPath = path.join(dir, "config.json");
+  for (const content of ['{ broken', "", "[]", '"x"']) {
+    await fs.writeFile(configPath, content);
+    assert.throws(() => paths.ensureConfig(), /invalid mindroot configuration|expected a JSON object/);
+    assert.equal(await fs.readFile(configPath, "utf8"), content);
+  }
+});