reflect-mcp 1.0.5 → 1.0.6

package/README.md

@@ -125,6 +125,8 @@ npx reflect-mcp uninstall
 - Verify database path exists at default location
 - Try specifying custom path: `npx reflect-mcp install /path/to/db`
 
+## Demo:
+https://www.loom.com/share/455b1d3eb7184bdea1ae4e8d5904fc53
 ## License
 
 MIT

package/dist/pkcehandler.js

@@ -223,7 +223,6 @@ export class PKCEOAuthProxy {
     // Handle /oauth/token - exchange proxy code for access token
     // FastMCP expects a TokenResponse object, not a Response
     async exchangeAuthorizationCode(params) {
-        console.log("[PKCEProxy] exchangeAuthorizationCode called with code:", params.code?.slice(0, 8) + "...");
         if (!params.code) {
             throw new OAuthProxyError("invalid_request", "Missing authorization code", 400);
         }

package/dist/tools/index.js

@@ -11,7 +11,7 @@ export function registerTools(server, dbPath) {
     // Tool: Get all Reflect graphs
     server.addTool({
         name: "get_graphs",
-        description: "Get a list of all Reflect graphs accessible with the current access token",
+        description: "Get a list of all Reflect graphs.",
         parameters: z.object({}),
         execute: async (_args, { session }) => {
             if (!session) {
@@ -59,14 +59,14 @@ export function registerTools(server, dbPath) {
     // Tool: Get backlinks for a note from local Reflect SQLite database
     server.addTool({
         name: "get_backlinks",
-        description: "Get backlinks for a note from the local Reflect database. Returns notes that link to the specified note.",
+        description: "Get backlinks for a note from Reflect. Use  this tool to get more context about a note after calling the get_note tool.",
         parameters: z.object({
             subject: z.string().describe("The subject/title of the note to get backlinks for"),
-            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
             limit: z.number().default(10).describe("Maximum number of backlinks to return"),
         }),
         execute: async (args) => {
-            const { subject, graphId, limit } = args;
+            const { subject, graph_id, limit } = args;
             try {
                 const dbFile = resolvedDbPath;
                 const db = new Database(dbFile, { readonly: true });
@@ -79,7 +79,7 @@ export function registerTools(server, dbPath) {
           ORDER BY bl.updatedAt DESC
           LIMIT ?
         `);
-                const results = stmt.all(subject, graphId, limit);
+                const results = stmt.all(subject, graph_id, limit);
                 db.close();
                 const backlinks = results.map((row) => ({
                     fromSubject: row.from_subject,
@@ -91,7 +91,7 @@ export function registerTools(server, dbPath) {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ subject, graphId, backlinks }, null, 2),
+                            text: JSON.stringify({ subject, graph_id, backlinks }, null, 2),
                         },
                     ],
                 };
@@ -111,13 +111,13 @@ export function registerTools(server, dbPath) {
     // Tool: Get recent daily notes
     server.addTool({
         name: "get_daily_notes",
-        description: "Get the most recent daily notes from the local Reflect database",
+        description: "Get the most recent daily notes from Reflect.",
         parameters: z.object({
             limit: z.number().default(5).describe("Number of recent daily notes to return"),
-            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
         }),
         execute: async (args) => {
-            const { limit, graphId } = args;
+            const { limit, graph_id } = args;
             try {
                 const dbFile = resolvedDbPath;
                 const db = new Database(dbFile, { readonly: true });
@@ -128,7 +128,7 @@ export function registerTools(server, dbPath) {
           ORDER BY dailyDate DESC
           LIMIT ?
         `);
-                const rows = stmt.all(graphId, limit);
+                const rows = stmt.all(graph_id, limit);
                 db.close();
                 const dailyNotes = rows.map((row) => ({
                     id: row.id,
@@ -137,13 +137,13 @@ export function registerTools(server, dbPath) {
                     editedAt: formatDate(row.editedAt),
                     tags: row.tags ? JSON.parse(row.tags) : [],
                     dailyDate: formatDate(row.dailyDate),
-                    graphId: row.graphId,
+                    graph_id: row.graphId,
                 }));
                 return {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ graphId, count: dailyNotes.length, dailyNotes }, null, 2),
+                            text: JSON.stringify({ graph_id, count: dailyNotes.length, dailyNotes }, null, 2),
                         },
                     ],
                 };
@@ -163,13 +163,13 @@ export function registerTools(server, dbPath) {
     // Tool: Get daily note by date
     server.addTool({
         name: "get_daily_note_by_date",
-        description: "Get the daily note for a specific date from the local Reflect database",
+        description: "Get the daily note for a specific date.",
         parameters: z.object({
             date: z.string().describe("The date in YYYY-MM-DD format"),
-            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
         }),
         execute: async (args) => {
-            const { date, graphId } = args;
+            const { date, graph_id } = args;
             try {
                 const dbFile = resolvedDbPath;
                 const db = new Database(dbFile, { readonly: true });
@@ -180,14 +180,14 @@ export function registerTools(server, dbPath) {
           FROM notes 
           WHERE isDaily = 1 AND isDeleted = 0 AND graphId = ? AND dailyDate = ?
         `);
-                const result = stmt.get(graphId, dateMs);
+                const result = stmt.get(graph_id, dateMs);
                 db.close();
                 if (!result) {
                     return {
                         content: [
                             {
                                 type: "text",
-                                text: JSON.stringify({ error: `No daily note found for ${date}`, date, graphId }),
+                                text: JSON.stringify({ error: `No daily note found for ${date}`, date, graph_id }),
                             },
                         ],
                     };
@@ -199,13 +199,13 @@ export function registerTools(server, dbPath) {
                     editedAt: formatDate(result.editedAt),
                     tags: result.tags ? JSON.parse(result.tags) : [],
                     dailyDate: formatDate(result.dailyDate),
-                    graphId: result.graphId,
+                    graph_id: result.graph_id,
                 };
                 return {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ date, graphId, dailyNote }, null, 2),
+                            text: JSON.stringify({ date, graph_id, dailyNote }, null, 2),
                         },
                     ],
                 };
@@ -225,14 +225,14 @@ export function registerTools(server, dbPath) {
     // Tool: Get notes with most backlinks
     server.addTool({
         name: "get_backlinked_notes",
-        description: "Get notes that have at least a minimum number of backlinks from the local Reflect database",
+        description: "Get notes that have at least a minimum number of backlinks from Reflect.",
         parameters: z.object({
             minBacklinks: z.number().default(5).describe("Minimum number of backlinks a note must have"),
             limit: z.number().default(10).describe("Maximum number of notes to return"),
-            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
         }),
         execute: async (args) => {
-            const { minBacklinks, limit, graphId } = args;
+            const { minBacklinks, limit, graph_id } = args;
             try {
                 const dbFile = resolvedDbPath;
                 const db = new Database(dbFile, { readonly: true });
@@ -246,7 +246,7 @@ export function registerTools(server, dbPath) {
           ORDER BY backlink_count DESC
           LIMIT ?
         `);
-                const results = stmt.all(graphId, minBacklinks, limit);
+                const results = stmt.all(graph_id, minBacklinks, limit);
                 db.close();
                 const notes = results.map((row) => ({
                     id: row.id,
@@ -258,7 +258,7 @@ export function registerTools(server, dbPath) {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ graphId, minBacklinks, count: notes.length, notes }, null, 2),
+                            text: JSON.stringify({ graph_id, minBacklinks, count: notes.length, notes }, null, 2),
                         },
                     ],
                 };
@@ -278,13 +278,13 @@ export function registerTools(server, dbPath) {
     // Tool: Get all tags with usage counts
     server.addTool({
         name: "get_tags",
-        description: "Get all unique tags with their usage counts from the local Reflect database",
+        description: "Get all unique tags with their usage counts from Reflect.",
         parameters: z.object({
-            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
             limit: z.number().default(50).describe("Maximum number of tags to return"),
         }),
         execute: async (args) => {
-            const { graphId, limit } = args;
+            const { graph_id, limit } = args;
             try {
                 const dbFile = resolvedDbPath;
                 const db = new Database(dbFile, { readonly: true });
@@ -292,7 +292,7 @@ export function registerTools(server, dbPath) {
           SELECT tags FROM notes 
           WHERE isDeleted = 0 AND graphId = ? AND tags IS NOT NULL AND tags != '[]'
         `);
-                const rows = stmt.all(graphId);
+                const rows = stmt.all(graph_id);
                 db.close();
                 const tagCounts = {};
                 for (const row of rows) {
@@ -314,7 +314,7 @@ export function registerTools(server, dbPath) {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ graphId, totalTags: Object.keys(tagCounts).length, tags: sortedTags }, null, 2),
+                            text: JSON.stringify({ graph_id, totalTags: Object.keys(tagCounts).length, tags: sortedTags }, null, 2),
                         },
                     ],
                 };
@@ -334,14 +334,14 @@ export function registerTools(server, dbPath) {
     // Tool: Get notes with a specific tag
     server.addTool({
         name: "get_notes_with_tag",
-        description: "Get notes that have a specific tag from the local Reflect database",
+        description: "Get notes that have a specific tag from Reflect.",
         parameters: z.object({
             tag: z.string().describe("The tag to search for"),
-            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
             limit: z.number().default(20).describe("Maximum number of notes to return"),
         }),
         execute: async (args) => {
-            const { tag, graphId, limit } = args;
+            const { tag, graph_id, limit } = args;
             try {
                 const dbFile = resolvedDbPath;
                 const db = new Database(dbFile, { readonly: true });
@@ -352,7 +352,7 @@ export function registerTools(server, dbPath) {
           ORDER BY editedAt DESC
           LIMIT ?
         `);
-                const results = stmt.all(graphId, `%"${tag}"%`, limit);
+                const results = stmt.all(graph_id, `%"${tag}"%`, limit);
                 db.close();
                 const notes = results.map((row) => ({
                     id: row.id,
@@ -366,7 +366,7 @@ export function registerTools(server, dbPath) {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ tag, graphId, count: notes.length, notes }, null, 2),
+                            text: JSON.stringify({ tag, graph_id, count: notes.length, notes }, null, 2),
                         },
                     ],
                 };
@@ -383,49 +383,116 @@ export function registerTools(server, dbPath) {
             }
         },
     });
-    // Tool: Get a note by title
+    // Tool: Get a note by title (exact match first, then fuzzy fallback)
     server.addTool({
         name: "get_note",
-        description: "Get a note by its title (subject) from the local Reflect database",
+        description: "Get a note by its title (subject) from Reflect.",
         parameters: z.object({
             title: z.string().describe("The title/subject of the note to retrieve"),
-            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
         }),
         execute: async (args) => {
-            const { title, graphId } = args;
+            const { title, graph_id } = args;
+            const FUZZY_LIMIT = 3;
             try {
                 const dbFile = resolvedDbPath;
                 const db = new Database(dbFile, { readonly: true });
-                const stmt = db.prepare(`
+                // Try exact match first
+                const exactStmt = db.prepare(`
           SELECT id, subject, documentText, tags, editedAt, createdAt
           FROM notes 
           WHERE isDeleted = 0 AND graphId = ? AND subject = ?
         `);
-                const result = stmt.get(graphId, title);
+                const exactResult = exactStmt.get(graph_id, title);
+                if (exactResult) {
+                    db.close();
+                    const note = {
+                        id: exactResult.id,
+                        subject: exactResult.subject,
+                        documentText: exactResult.documentText,
+                        tags: exactResult.tags ? JSON.parse(exactResult.tags) : [],
+                        editedAt: formatDate(exactResult.editedAt),
+                        createdAt: formatDate(exactResult.createdAt),
+                    };
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({ title, graph_id, note }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                // No exact match - try fuzzy search
+                const searchTerm = title.toLowerCase();
+                const fuzzyStmt = db.prepare(`
+          SELECT id, subject, documentText, tags, editedAt, createdAt,
+            CASE 
+              WHEN LOWER(subject) LIKE ? THEN 2
+              WHEN LOWER(subject) LIKE ? THEN 1
+              ELSE 0
+            END as relevance
+          FROM notes 
+          WHERE isDeleted = 0 
+            AND graphId = ? 
+            AND (LOWER(subject) LIKE ? OR LOWER(subject) LIKE ?)
+          ORDER BY relevance DESC, editedAt DESC
+          LIMIT ?
+        `);
+                const fuzzyResults = fuzzyStmt.all(`${searchTerm}%`, // starts with (score 2)
+                `%${searchTerm}%`, // contains (score 1)
+                graph_id, `${searchTerm}%`, // WHERE starts with
+                `%${searchTerm}%`, // WHERE contains
+                FUZZY_LIMIT);
                 db.close();
-                if (!result) {
+                if (fuzzyResults.length === 0) {
                     return {
                         content: [
                             {
                                 type: "text",
-                                text: JSON.stringify({ error: `Note '${title}' not found`, title, graphId }),
+                                text: JSON.stringify({
+                                    error: `No notes found matching '${title}'`,
+                                    query: title,
+                                    graph_id
+                                }),
                             },
                         ],
                     };
                 }
-                const note = {
+                const notes = fuzzyResults.map((result) => ({
                     id: result.id,
                     subject: result.subject,
                     documentText: result.documentText,
                     tags: result.tags ? JSON.parse(result.tags) : [],
                     editedAt: formatDate(result.editedAt),
                     createdAt: formatDate(result.createdAt),
-                };
+                }));
+                // If only one fuzzy match, return it directly
+                if (notes.length === 1) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    query: title,
+                                    graph_id,
+                                    note: notes[0],
+                                    matchType: "fuzzy"
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
                 return {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ title, graphId, note }, null, 2),
+                            text: JSON.stringify({
+                                query: title,
+                                graph_id,
+                                matchCount: notes.length,
+                                notes
+                            }, null, 2),
                         },
                     ],
                 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reflect-mcp",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "MCP server for Reflect Notes - connect your notes to Claude Desktop. Just run: npx reflect-mcp",
   "type": "module",
   "main": "dist/server.js",
@@ -15,7 +15,8 @@
     "build": "tsc",
     "dev": "tsx src/cli.ts",
     "start": "node dist/cli.js",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "postinstall": "npm rebuild better-sqlite3 || true"
   },
   "keywords": [
     "mcp",
@@ -36,8 +37,9 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "better-sqlite3": "^11.0.0",
+    "better-sqlite3": "^11.10.0",
     "fastmcp": "^3.25.4",
+    "reflect-mcp": "^1.0.3",
     "zod": "^4.1.13"
   },
   "devDependencies": {