@sksoftofficial/mindroot 1.0.0

package/README.md

@@ -0,0 +1,94 @@
+# Mindroot
+
+Persistent two-layer memory system for AI agents. Embedding-searched **memories** over human-editable markdown **notes**, exposed through a local HTTP service with an MCP interface.
+
+- **Notes** (Layer 2): human-editable markdown files under `~/.mindroot/notes/<project>/`, parsed into heading-addressable sections. The unit of storage.
+- **Memories** (Layer 1): short, retrieval-optimized texts linked (or standalone) that point into notes. Embedded and full-text indexed. The unit of retrieval.
+- **Search**: hybrid semantic (embeddinggemma-300m ONNX) + keyword (SQLite FTS5/bm25), strictly project-scoped. Fuzzy project-name matching included (`search_projects`).
+
+- Website: https://skbilisim.com/en/projects/mindroot
+- npm: https://www.npmjs.com/package/@sksoftofficial/mindroot
+
+## Install
+
+Requires Node.js >= 22.
+
+```sh
+npm install -g mindroot   # or: npm link from a clone
+mindroot init             # creates store, caches the embedding model (~316MB)
+mindroot start            # daemonizes and waits until healthy
+```
+
+## Quick start (MCP)
+
+Point your MCP client at the service:
+
+```json
+{
+  "mcpServers": {
+    "mindroot": {
+      "type": "remote",
+      "url": "http://127.0.0.1:7620/mcp",
+      "headers": { "Authorization": "Bearer <apiKey>" }
+    }
+  }
+}
+```
+
+The API key is generated by `mindroot init` and stored in `~/.mindroot/config.json` (never printed). Dashboard lives at `http://127.0.0.1:7620/`.
+
+For how agents should actually *use* this memory day-to-day, see [INSTRUCTIONS.md](./INSTRUCTIONS.md) — a ready-made memory policy you can drop into your agent's configuration.
+
+## CLI
+
+| Command | Description |
+|---|---|
+| `mindroot init` | Initialize store + model cache (idempotent) |
+| `mindroot start [--foreground]` | Daemonize the service (or run foreground for debugging) |
+| `mindroot stop` | Stop the running service |
+| `mindroot status` | Show whether the service is running |
+| `mindroot projects` | List projects with counts |
+| `mindroot notes --project <slug> [path]` | List notes, or print one |
+| `mindroot memories --project <slug>` | List memories |
+| `mindroot save-memory "<text>" --project <slug> [--link "note.md::Heading"]` | Save a memory |
+| `mindroot search "<query>" --project <slug> [--limit N]` | Search memories + notes |
+
+## MCP tools
+
+All tools are prefixed `mindroot_`.
+
+| Tool | Params | Purpose |
+|---|---|---|
+| `list_projects` | — | Discover slugs |
+| `search_projects` | `query` | Fuzzy-find a project by name |
+| `search_memories` | `project*`, `query`, `limit?` | Hybrid search over memories (hits carry ids) |
+| `search_notes` | `project*`, `query`, `limit?` | Search note sections |
+| `save_memory` | `project*`, `text`, `target_path?` | Save a memory, optionally linked to a note/section |
+| `delete_memory` | `project*`, `id` | Delete a memory by id |
+| `list_notes` | `project*` | List notes with section paths |
+| `read_note` | `project*`, `path` | Full note content (hash-verified) |
+| `save_note` | `project*`, `path`, `content` | Create/overwrite a note |
+| `update_section` | `project*`, `path`, `heading_path`, `content` | Replace one section body |
+| `delete_note` | `project*`, `path` | Delete a note |
+
+## Configuration
+
+Everything lives under `~/.mindroot/`:
+
+- `config.json` — `port` (default 7620) and `apiKey`
+- `notes/<project>/` — your markdown notes
+- `models/` — cached ONNX embedding model
+- `mindroot.db` — SQLite index (WAL mode)
+- `mindroot.pid` / `mindroot.log` — written by `start`/`stop`
+
+Set `MINDROOT_DIR` to relocate the whole store.
+
+## Development
+
+```sh
+node --test    # runs the test suite in test/
+```
+
+## License
+
+MIT

package/bin/mindroot.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+import { init } from "../src/commands/init.js";
+import { start, stop, status } from "../src/commands/start.js";
+import { projects, searchCmd, saveMemoryCmd, memoriesCmd, notesCmd } from "../src/commands/human.js";
+
+const [command, ...rest] = process.argv.slice(2);
+
+const usage = `mindroot — persistent memory for AI agents
+
+Usage:
+  mindroot init                          Initialize store and download model
+  mindroot start [--foreground]          Start the service in the background (or foreground)
+  mindroot stop                          Stop the running service
+  mindroot status                        Show whether the service is running
+  mindroot projects                      List projects
+  mindroot notes --project <slug> [path] List notes (or show one)
+  mindroot memories --project <slug>     List memories
+  mindroot save-memory <text> --project <slug> [--link "note.md::Heading"]
+  mindroot search "query" --project <slug> [--limit N]
+`;
+
+async function main() {
+  switch (command) {
+    case undefined:
+    case "--help":
+    case "-h":
+    case "help":
+      return console.log(usage);
+    case "init":
+      return init();
+    case "start":
+      return start(rest);
+    case "stop":
+      return stop();
+    case "status":
+      return status();
+    case "projects":
+      return projects();
+    case "notes":
+      return notesCmd(rest);
+    case "memories":
+      return memoriesCmd(rest);
+    case "save-memory":
+      return saveMemoryCmd(rest);
+    case "search":
+      return searchCmd(rest);
+    default:
+      console.log(`unknown command: ${command}\n\n${usage}`);
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(`error: ${err.message ?? err}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@sksoftofficial/mindroot",
+  "version": "1.0.0",
+  "description": "Persistent two-layer memory for AI agents: embedding-searched memories over human-editable markdown facts. Runs as a local background service.",
+  "homepage": "https://skbilisim.com/en/projects/mindroot",
+  "type": "module",
+  "bin": {
+    "mindroot": "./bin/mindroot.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "test/"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "memory",
+    "embeddings",
+    "mcp",
+    "markdown"
+  ],
+  "author": "sksoftofficial",
+  "license": "ISC",
+  "dependencies": {
+    "@huggingface/transformers": "^3.7.5"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}

package/src/commands/cli-api.js

@@ -0,0 +1,42 @@
+import { loadConfig } from "../paths.js";
+
+function base() {
+  const cfg = loadConfig();
+  return `http://127.0.0.1:${cfg.port ?? 7620}`;
+}
+
+export async function api(method, pathname, body) {
+  let res;
+  try {
+    res = await fetch(base() + pathname, {
+      method,
+      headers: {
+        authorization: `Bearer ${loadConfig().apiKey ?? ""}`,
+        "content-type": "application/json",
+      },
+      body: body === undefined ? undefined : JSON.stringify(body),
+    });
+  } catch (err) {
+    if (err.cause?.code === "ECONNREFUSED") {
+      throw new Error("mindroot service is not running — start it with: mindroot service");
+    }
+    throw err;
+  }
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error ?? `HTTP ${res.status}`);
+  return data;
+}
+
+export function parseArgs(argv) {
+  const positional = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i].startsWith("--")) {
+      flags[argv[i].slice(2)] = argv[i + 1];
+      i++;
+    } else {
+      positional.push(argv[i]);
+    }
+  }
+  return { positional, flags };
+}

package/src/commands/human.js

@@ -0,0 +1,79 @@
+import { api, parseArgs } from "./cli-api.js";
+
+function fmtDate(ts) {
+  return new Date(ts).toISOString().replace("T", " ").slice(0, 16);
+}
+
+function projectFlag(flags) {
+  const p = flags.project;
+  if (!p) throw new Error("--project <slug> is required");
+  return p;
+}
+
+export async function projects() {
+  const rows = await api("GET", "/api/projects");
+  if (!rows.length) return console.log("no projects yet");
+  for (const r of rows) {
+    console.log(`${r.slug}  (${r.docs} notes, ${r.memories} memories)`);
+  }
+}
+
+export async function searchCmd(argv) {
+  const { positional, flags } = parseArgs(argv);
+  const query = positional.join(" ");
+  if (!query) throw new Error('usage: mindroot search "query" --project <slug>');
+  const hits = await api("POST", "/api/search", {
+    project: projectFlag(flags),
+    query,
+    limit: Number(flags.limit ?? 8),
+  });
+  if (!hits.length) return console.log("no results");
+  for (const [i, h] of hits.entries()) {
+    const target = h.target ? `\n    -> ${h.target}` : "";
+    console.log(`${i + 1}. [${h.score.toFixed(3)}] ${h.kind}${h.doc_title ? ` in "${h.doc_title}"` : ""}${target}`);
+    console.log(`   ${h.text.replace(/\s+/g, " ").slice(0, 200)}`);
+    console.log(`   updated ${fmtDate(h.updated_at)}`);
+  }
+}
+
+export async function saveMemoryCmd(argv) {
+  const { positional, flags } = parseArgs(argv);
+  const text = positional.join(" ");
+  if (!text) throw new Error('usage: mindroot save-memory "text" --project <slug> [--link "note.md::Heading"]');
+  const out = await api("POST", `/api/projects/${flags.project}/memories`, {
+    text,
+    target_path: flags.link,
+  });
+  console.log(`saved memory #${out.id} (${out.target_type})`);
+}
+
+export async function memoriesCmd(argv) {
+  const { flags } = parseArgs(argv);
+  const rows = await api("GET", `/api/projects/${projectFlag(flags)}/memories`);
+  if (!rows.length) return console.log("no memories");
+  for (const r of rows) {
+    console.log(`#${r.id}  ${r.text}`);
+    if (r.target_path) console.log(`     -> ${r.target_path}`);
+  }
+}
+
+export async function notesCmd(argv) {
+  const { flags, positional } = parseArgs(argv);
+  const slug = projectFlag(flags);
+  if (positional[0]) {
+    const doc = await api("GET", `/api/projects/${slug}/doc?path=${encodeURIComponent(positional[0])}`);
+    console.log(`# ${doc.title}\n`);
+    for (const s of doc.sections) {
+      console.log(s.path ? `[${s.path}]` : "[preamble]");
+    }
+    console.log("\n" + "-".repeat(40));
+    process.stdout.write(doc.content);
+    return;
+  }
+  const docs = await api("GET", `/api/projects/${slug}/docs`);
+  if (!docs.length) return console.log("no notes");
+  for (const d of docs) {
+    console.log(`${d.path}  "${d.title}" (${d.sections.length} sections)`);
+    for (const s of d.sections) console.log(`   - ${s || "(preamble)"}`);
+  }
+}

package/src/commands/init.js

@@ -0,0 +1,25 @@
+import { mkdir } from "node:fs/promises";
+import { MINDROOT_DIR, MODELS_DIR, NOTES_DIR, ensureConfig } from "../paths.js";
+import { open } from "../store/db.js";
+import { getEmbedder } from "../embedder.js";
+
+export async function init() {
+  await mkdir(MODELS_DIR, { recursive: true });
+  await mkdir(NOTES_DIR, { recursive: true });
+
+  const db = open();
+  db.close();
+
+  const { cfg, created } = ensureConfig();
+
+  console.log(`initializing memory store at ${MINDROOT_DIR}`);
+  console.log("fetching embedding model (embeddinggemma-300m ONNX q8)...");
+  await getEmbedder();
+  console.log("model cached");
+
+  if (created) {
+    console.log(`\nAPI key generated and stored in ${MINDROOT_DIR}/config.json\n`);
+  } else {
+    console.log(`memory store ready at ${MINDROOT_DIR}`);
+  }
+}

package/src/commands/start.js

@@ -0,0 +1,162 @@
+import fsSync from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { DEFAULT_PORT, MINDROOT_DIR, ensureConfig } from "../paths.js";
+import { open } from "../store/db.js";
+import { createServer } from "../server.js";
+
+const BIN_PATH = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "..",
+  "bin",
+  "mindroot.js",
+);
+const PID_FILE = path.join(MINDROOT_DIR, "mindroot.pid");
+const LOG_FILE = path.join(MINDROOT_DIR, "mindroot.log");
+
+function readPid() {
+  try {
+    return Number(fsSync.readFileSync(PID_FILE, "utf8").trim());
+  } catch {
+    return null;
+  }
+}
+
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function healthy(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(1000) });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function waitFor(port, ms) {
+  const deadline = Date.now() + ms;
+  while (Date.now() < deadline) {
+    if (await healthy(port)) return true;
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  return false;
+}
+
+export function isRunning(cfg) {
+  const pid = readPid();
+  return pid !== null && pidAlive(pid) ? pid : null;
+}
+
+export async function start(argv = []) {
+  const { cfg } = ensureConfig();
+
+  if (argv.includes("--foreground")) {
+    return runForeground(cfg);
+  }
+
+  const existing = isRunning(cfg);
+  if (existing) {
+    console.log(`mindroot already running (pid ${existing})`);
+    return;
+  }
+
+  fsSync.mkdirSync(MINDROOT_DIR, { recursive: true });
+  const out = fsSync.openSync(LOG_FILE, "a");
+  const child = spawn(process.execPath, [BIN_PATH, "start", "--foreground"], {
+    detached: true,
+    stdio: ["ignore", out, out],
+  });
+  child.unref();
+  fsSync.writeFileSync(PID_FILE, String(child.pid));
+
+  console.log(`starting mindroot on http://127.0.0.1:${cfg.port} ...`);
+  if (await waitFor(cfg.port, 15000)) {
+    console.log(`started (pid ${child.pid})`);
+    console.log(`dashboard: http://127.0.0.1:${cfg.port}/`);
+    console.log(`logs: ${LOG_FILE}`);
+    console.log(`stop: mindroot stop`);
+  } else {
+    console.error(`failed to start — last log lines:`);
+    try {
+      const log = fsSync.readFileSync(LOG_FILE, "utf8").trimEnd();
+      console.error(log.split("\n").slice(-10).join("\n"));
+    } catch {}
+    try { fsSync.unlinkSync(PID_FILE); } catch {}
+    process.exitCode = 1;
+  }
+}
+
+function runForeground(cfg) {
+  fsSync.writeFileSync(PID_FILE, String(process.pid));
+  const db = open();
+  const server = createServer(db, cfg);
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(`port ${cfg.port} is already in use — is mindroot already running? (port config: ${MINDROOT_DIR}/config.json)`);
+      process.exit(1);
+    }
+    throw err;
+  });
+  server.listen(cfg.port, "127.0.0.1", () => {
+    console.log(`mindroot listening on http://127.0.0.1:${cfg.port}`);
+    console.log(`press Ctrl+C to stop`);
+  });
+  const shutdown = () => {
+    server.close(() => process.exit(0));
+    try { fsSync.unlinkSync(PID_FILE); } catch {}
+    setTimeout(() => process.exit(0), 1500).unref();
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+export async function stop() {
+  const pid = readPid();
+  if (pid === null || !pidAlive(pid)) {
+    try { fsSync.unlinkSync(PID_FILE); } catch {}
+    console.log("mindroot is not running");
+    return;
+  }
+  process.kill(pid, "SIGTERM");
+  for (let i = 0; i < 30 && pidAlive(pid); i++) {
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  if (pidAlive(pid)) {
+    process.kill(pid, "SIGKILL");
+  }
+  try { fsSync.unlinkSync(PID_FILE); } catch {}
+  console.log(`stopped (pid ${pid})`);
+}
+
+export async function status() {
+  const { cfg } = ensureConfig();
+  const pid = isRunning(cfg);
+  if (pid === null) {
+    console.log("mindroot is not running");
+    return;
+  }
+  const port = cfg.port ?? DEFAULT_PORT;
+  const ok = await healthy(port);
+  let auth = "unknown";
+  if (ok) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/api/projects`, {
+        headers: { authorization: `Bearer ${cfg.apiKey}` },
+        signal: AbortSignal.timeout(2000),
+      });
+      auth = res.ok ? "key ok" : "KEY MISMATCH — update your MCP client's Bearer key from ~/.mindroot/config.json";
+    } catch {
+      auth = "check failed";
+    }
+  }
+  console.log(`mindroot is running (pid ${pid}, http://127.0.0.1:${port}, health: ${ok ? "ok" : "unreachable"}, auth: ${auth})`);
+}

package/src/core.js

@@ -0,0 +1,176 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import {
+  projectDir,
+  safeJoin,
+  validSlug,
+  ensureProject,
+  getProjectRow,
+  verifyAndLoadDoc,
+  reindexDoc,
+  httpError,
+} from "./indexer.js";
+import { parseMarkdown, replaceSectionBody } from "./markdown.js";
+import { embedDoc } from "./embedder.js";
+import { ONNX_MODEL_ID } from "./paths.js";
+import { searchMemories as hybridSearchMemories, searchNotes as hybridSearchNotes, searchProjects } from "./search.js";
+
+export { searchProjects };
+
+export async function listProjects(db) {
+  return db
+    .prepare(
+      `SELECT p.slug, p.created_at,
+              (SELECT COUNT(*) FROM docs d WHERE d.project_id = p.id) AS docs,
+              (SELECT COUNT(*) FROM memories m WHERE m.project_id = p.id) AS memories
+       FROM projects p ORDER BY p.slug`,
+    )
+    .all();
+}
+
+export function getProject(db, slug) {
+  return getProjectRow(db, slug);
+}
+
+export async function deleteProject(db, slug) {
+  const project = getProjectRow(db, slug);
+  await fs.rm(projectDir(slug), { recursive: true, force: true });
+  db.prepare("DELETE FROM projects WHERE id = ?").run(project.id);
+  return { deleted: slug };
+}
+
+export async function listDocs(db, slug) {
+  const project = getProjectRow(db, slug);
+  const docs = db
+    .prepare("SELECT id, rel_path, title, indexed_at FROM docs WHERE project_id = ? ORDER BY rel_path")
+    .all(project.id);
+  const result = [];
+  for (const doc of docs) {
+    const sections = db
+      .prepare("SELECT heading_path FROM sections WHERE doc_id = ? ORDER BY id")
+      .all(doc.id)
+      .map((r) => r.heading_path);
+    result.push({ path: doc.rel_path, title: doc.title, sections });
+  }
+  return result;
+}
+
+export async function readNote(db, slug, relPath) {
+  await verifyAndLoadDoc(db, slug, relPath);
+  const project = getProjectRow(db, slug);
+  const doc = db
+    .prepare("SELECT * FROM docs WHERE project_id = ? AND rel_path = ?")
+    .get(project.id, relPath);
+  const content = await fs.readFile(safeJoin(slug, relPath), "utf8");
+  const parsed = parseMarkdown(content);
+  return {
+    path: relPath,
+    title: doc.title,
+    updated_at: doc.indexed_at,
+    sections: parsed.sections.map((s) => ({ path: s.path, level: s.level })),
+    content,
+  };
+}
+
+export async function saveNote(db, slug, relPath, content) {
+  const full = safeJoin(slug, relPath);
+  await fs.mkdir(path.dirname(full), { recursive: true });
+  await fs.writeFile(full, content, "utf8");
+  const stat = await fs.stat(full);
+  await reindexDoc(db, slug, relPath, content, Math.floor(stat.mtimeMs));
+  return readNote(db, slug, relPath);
+}
+
+export async function deleteNote(db, slug, relPath) {
+  const full = safeJoin(slug, relPath);
+  const project = getProjectRow(db, slug);
+  try {
+    await fs.unlink(full);
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  const doc = db
+    .prepare("SELECT id FROM docs WHERE project_id = ? AND rel_path = ?")
+    .get(project.id, relPath);
+  if (doc) {
+    const ids = db.prepare("SELECT id FROM sections WHERE doc_id = ?").all(doc.id).map((r) => r.id);
+    for (const sid of ids) {
+      db.prepare("DELETE FROM embeddings WHERE owner_type = 'section' AND owner_id = ?").run(sid);
+    }
+    db.prepare("DELETE FROM docs WHERE id = ?").run(doc.id);
+  }
+  db.prepare(
+    "UPDATE memories SET target_path = NULL, updated_at = ? WHERE project_id = ? AND (target_path = ? OR target_path LIKE ?)",
+  ).run(Date.now(), project.id, relPath, relPath + "::%");
+  return { deleted: relPath };
+}
+
+export async function updateSection(db, slug, relPath, headingPath, newContent) {
+  const { content } = await verifyAndLoadDoc(db, slug, relPath);
+  const parsed = parseMarkdown(content);
+  const sec = parsed.sections.find((s) => s.path === headingPath);
+  if (!sec) throw httpError(404, `section not found: ${headingPath}`);
+  const updated = replaceSectionBody(content, sec, newContent);
+  return saveNote(db, slug, relPath, updated);
+}
+
+export async function listMemories(db, slug) {
+  const project = getProjectRow(db, slug);
+  return db
+    .prepare(
+      "SELECT id, text, target_type, target_path, created_at, updated_at FROM memories WHERE project_id = ? ORDER BY id",
+    )
+    .all(project.id);
+}
+
+export async function addMemory(db, slug, text, targetPath) {
+  if (!text?.trim()) throw httpError(400, "memory text is required");
+  let targetType = "standalone";
+  if (targetPath) {
+    if (!targetPath.includes(".md")) throw httpError(400, "target_path must reference a note (.md or .md::Heading)");
+    targetType = targetPath.includes("::") ? "section" : "doc";
+  }
+  const project = getProjectRow(db, slug) ?? ensureProject(db, slug);
+  const now = Date.now();
+  const res = db
+    .prepare(
+      "INSERT INTO memories (project_id, text, target_type, target_path, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
+    )
+    .run(project.id, text.trim(), targetType, targetPath ?? null, now, now);
+  const id = Number(res.lastInsertRowid);
+  const vec = await embedDoc(text.trim());
+  db.prepare(
+    "INSERT INTO embeddings (owner_type, owner_id, dim, model, vec) VALUES ('memory', ?, ?, ?, ?)",
+  ).run(id, vec.length, ONNX_MODEL_ID, Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength));
+  return { id, target_type: targetType };
+}
+
+export async function deleteMemory(db, slug, id) {
+  const project = getProjectRow(db, slug);
+  const row = db
+    .prepare("SELECT id FROM memories WHERE project_id = ? AND id = ?")
+    .get(project.id, id);
+  if (!row) throw httpError(404, `memory not found: ${id}`);
+  db.prepare("DELETE FROM embeddings WHERE owner_type = 'memory' AND owner_id = ?").run(id);
+  db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+  return { deleted: id };
+}
+
+function scopedProject(db, slug) {
+  if (!slug) throw httpError(400, "project is required");
+  return getProjectRow(db, slug).id;
+}
+
+function cleanLimit(limit) {
+  const n = Number(limit);
+  if (!Number.isFinite(n)) return 8;
+  return Math.min(Math.max(Math.floor(n), 1), 100);
+}
+
+export async function searchMemories(db, slug, query, limit) {
+  return hybridSearchMemories(db, scopedProject(db, slug), query, cleanLimit(limit));
+}
+
+export async function searchNotes(db, slug, query, limit) {
+  return hybridSearchNotes(db, scopedProject(db, slug), query, cleanLimit(limit));
+}