daleel-mcp 1.0.0 → 1.1.0

package/dist/db.d.ts

@@ -15,6 +15,7 @@ declare class DaleelDiscoveryEngine {
     constructor();
     private detectAppDataDir;
     private initAppDb;
+    getAppDb(): any;
     getAppDataPath(): string | null;
     getInstalledPackages(): InstalledPackage[];
     openPackageDb(localFileName: string): any | null;

package/dist/db.js

@@ -13,12 +13,10 @@ class DaleelDiscoveryEngine {
         this.initAppDb();
     }
     detectAppDataDir() {
-        // 1. Explicit environment variable
         if (process.env.DALEEL_APP_DATA_DIR && fs.existsSync(process.env.DALEEL_APP_DATA_DIR)) {
             this.appDataDir = process.env.DALEEL_APP_DATA_DIR;
             return;
         }
-        // 2. Platform default paths for Daleel Scholar (Tauri identifier: com.daleel.scholar)
         const platform = os.platform();
         let candidate = "";
         if (platform === "win32") {
@@ -34,13 +32,6 @@ class DaleelDiscoveryEngine {
         if (fs.existsSync(candidate)) {
             this.appDataDir = candidate;
         }
-        else {
-            // Fallback check in case running inside the repo
-            const devPath = path.resolve(process.cwd(), "../../content-source/ur");
-            if (fs.existsSync(devPath)) {
-                this.appDataDir = devPath;
-            }
-        }
     }
     initAppDb() {
         if (!this.appDataDir)
@@ -48,7 +39,8 @@ class DaleelDiscoveryEngine {
         const appDbPath = path.join(this.appDataDir, "app.db");
         if (fs.existsSync(appDbPath)) {
             try {
-                this.appDb = new DatabaseSync(appDbPath, { readOnly: true });
+                // Open with read-write so MCP can sync timeline markers to Scholar App
+                this.appDb = new DatabaseSync(appDbPath);
             }
             catch (err) {
                 console.error("Failed to open app.db:", err);
@@ -64,6 +56,9 @@ class DaleelDiscoveryEngine {
             }
         }
     }
+    getAppDb() {
+        return this.appDb;
+    }
     getAppDataPath() {
         return this.appDataDir;
     }

package/dist/index.js

@@ -2,11 +2,11 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { listInstalledBooks, searchInBook, searchAllInstalledBooks, getBookPage, } from "./services.js";
+import { listInstalledBooks, searchInBook, getBookPage, verifyCitationAgainstDb, syncTimelineToScholarApp, getAppTimelineMarkers, validateScholarVideoAccess, getCurrentScholarProject, } from "./services.js";
 import { discoveryEngine } from "./db.js";
 const server = new Server({
-    name: "daleel-app-mcp",
-    version: "2.0.0",
+    name: "daleel-scholar-mcp",
+    version: "2.2.0",
 }, {
     capabilities: {
         tools: {},
@@ -16,68 +16,126 @@ const server = new Server({
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
         tools: [
+            {
+                name: "get_current_scholar_project",
+                description: "Checks which YouTube video is currently active or recently opened in the user's Daleel Scholar Desktop (Tauri) App. Use this first to auto-detect what the scholar is working on.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "validate_scholar_video_access",
+                description: "SECURITY GATEKEEPER: Verifies whether a given YouTube video ID exists in the scholar's authorized Daleel workspace. Rejects unknown or unauthorized videos.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        youtube_video_id: {
+                            type: "string",
+                            description: "YouTube 11-char Video ID (e.g. dQw4w9WgXcQ)",
+                        },
+                    },
+                    required: ["youtube_video_id"],
+                },
+            },
             {
                 name: "list_installed_books",
-                description: "List all Islamic books, Hadith collections, and Quran translations currently downloaded and installed in the user's Daleel Scholar App.",
+                description: "List all Islamic books, Hadith collections, and Tafseer works currently downloaded in Daleel Scholar App.",
                 inputSchema: {
                     type: "object",
                     properties: {},
                 },
             },
             {
-                name: "search_in_book",
-                description: "Search for specific text or keywords inside a specific downloaded book in Daleel App.",
+                name: "verify_citation_against_db",
+                description: "STRICT AUTHENTICITY: Verifies a religious claim or reference recited in a video by strictly checking Daleel SQLite database. Returns verified verbatim text or reports unverified.",
                 inputSchema: {
                     type: "object",
                     properties: {
                         book_identifier: {
                             type: "string",
-                            description: "Book ID, title, or filename (e.g. 'احکام و مسائل' or 'book-ahkaam-ahkam-wa-masail-jild-1')",
+                            description: "Book title or ID (e.g. 'احکام و مسائل' or 'fiqh')",
                         },
-                        query: {
+                        search_phrase: {
                             type: "string",
-                            description: "Text or keyword in Urdu/Arabic to search",
+                            description: "Specific Arabic or Urdu words mentioned in video",
                         },
-                        limit: {
+                        timestamp_seconds: {
                             type: "number",
-                            description: "Max pages to return (default: 5)",
+                            description: "Exact second timestamp in video",
+                        },
+                        speaker_claim: {
+                            type: "string",
+                            description: "What the speaker claimed in the video",
                         },
                     },
-                    required: ["book_identifier", "query"],
+                    required: ["book_identifier", "search_phrase", "timestamp_seconds", "speaker_claim"],
                 },
             },
             {
-                name: "search_all_installed_books",
-                description: "Search across all downloaded books in Daleel App simultaneously for a topic, keyword, or citation.",
+                name: "sync_timeline_to_scholar_app",
+                description: "Pushes verified citations and timestamps directly into Daleel Scholar Desktop (Tauri) App database so the user sees markers on the video timeline editor visually. Requires video to be registered in Scholar workspace.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        query: {
+                        youtube_video_id: {
                             type: "string",
-                            description: "Search keyword or phrase in Urdu/Arabic",
+                            description: "YouTube 11-char Video ID",
                         },
-                        limit: {
-                            type: "number",
-                            description: "Max results (default: 5)",
+                        video_title: {
+                            type: "string",
+                            description: "Title of the YouTube video",
                         },
+                        markers: {
+                            type: "array",
+                            description: "List of verified markers to place on the timeline",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    timestampSeconds: { type: "number" },
+                                    referenceTitle: { type: "string" },
+                                    exactText: { type: "string", description: "Verbatim text retrieved from Daleel DB" },
+                                    pageOrHadithNo: { type: "string" },
+                                },
+                                required: ["timestampSeconds", "referenceTitle", "exactText"],
+                            },
+                        },
+                    },
+                    required: ["youtube_video_id", "video_title", "markers"],
+                },
+            },
+            {
+                name: "get_video_timeline_markers",
+                description: "Fetch existing timeline markers saved in Daleel Scholar App for a given video.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        youtube_video_id: { type: "string" },
+                    },
+                    required: ["youtube_video_id"],
+                },
+            },
+            {
+                name: "search_in_book",
+                description: "Search for specific text or keywords inside a downloaded book in Daleel App.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        book_identifier: { type: "string" },
+                        query: { type: "string" },
+                        limit: { type: "number" },
                     },
-                    required: ["query"],
+                    required: ["book_identifier", "query"],
                 },
             },
             {
                 name: "get_book_page",
-                description: "Fetch the exact page content and footnotes from a specific downloaded book by page number.",
+                description: "Fetch the exact page content and footnotes from a book by page number.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        book_identifier: {
-                            type: "string",
-                            description: "Book ID, title, or filename",
-                        },
-                        page_number: {
-                            type: "number",
-                            description: "Exact page number (ID) to retrieve",
-                        },
+                        book_identifier: { type: "string" },
+                        page_number: { type: "number" },
                     },
                     required: ["book_identifier", "page_number"],
                 },
@@ -90,6 +148,26 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
         switch (name) {
+            case "get_current_scholar_project": {
+                const project = getCurrentScholarProject();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: project
+                                ? JSON.stringify(project, null, 2)
+                                : JSON.stringify({ isRegisteredInScholarApp: false, message: "No active video found in Daleel Scholar App. Please open a video in the desktop app first." }),
+                        },
+                    ],
+                };
+            }
+            case "validate_scholar_video_access": {
+                const { youtube_video_id } = args;
+                const validation = validateScholarVideoAccess(youtube_video_id);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(validation, null, 2) }],
+                };
+            }
             case "list_installed_books": {
                 const books = listInstalledBooks();
                 const appPath = discoveryEngine.getAppDataPath();
@@ -110,38 +188,33 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const { book_identifier, query, limit } = args;
                 const results = searchInBook(book_identifier, query, limit || 5);
                 return {
-                    content: [
-                        {
-                            type: "text",
-                            text: results.length
-                                ? JSON.stringify(results, null, 2)
-                                : `No occurrences of "${query}" found in ${book_identifier}.`,
-                        },
-                    ],
+                    content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
                 };
             }
-            case "search_all_installed_books": {
-                const { query, limit } = args;
-                const results = searchAllInstalledBooks(query, limit || 5);
+            case "verify_citation_against_db": {
+                const { book_identifier, search_phrase, timestamp_seconds, speaker_claim } = args;
+                const result = verifyCitationAgainstDb(book_identifier, search_phrase, timestamp_seconds, speaker_claim);
                 return {
-                    content: [
-                        {
-                            type: "text",
-                            text: results.length
-                                ? JSON.stringify(results, null, 2)
-                                : `No results found for "${query}" across downloaded books.`,
-                        },
-                    ],
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case "sync_timeline_to_scholar_app": {
+                const { youtube_video_id, video_title, markers } = args;
+                const res = syncTimelineToScholarApp(youtube_video_id, video_title, markers);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(res, null, 2) }],
+                };
+            }
+            case "get_video_timeline_markers": {
+                const { youtube_video_id } = args;
+                const res = getAppTimelineMarkers(youtube_video_id);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(res, null, 2) }],
                 };
             }
             case "get_book_page": {
                 const { book_identifier, page_number } = args;
                 const res = getBookPage(book_identifier, page_number);
-                if (!res) {
-                    return {
-                        content: [{ type: "text", text: `Page ${page_number} not found in ${book_identifier}.` }],
-                    };
-                }
                 return {
                     content: [{ type: "text", text: JSON.stringify(res, null, 2) }],
                 };
@@ -160,7 +233,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("Daleel Zero-Data MCP Server running on stdio");
+    console.error("Daleel Scholar Tauri-MCP Sync Server running on stdio");
 }
 main().catch((err) => {
     console.error("Fatal error:", err);

package/dist/services.d.ts

@@ -10,3 +10,37 @@ export declare function listInstalledBooks(): InstalledPackage[];
 export declare function searchInBook(packageIdOrFile: string, query: string, limit?: number): BookSearchResult[];
 export declare function searchAllInstalledBooks(query: string, limit?: number): BookSearchResult[];
 export declare function getBookPage(packageIdOrFile: string, pageNumber: number): any;
+export interface ScholarProjectValidation {
+    isRegisteredInScholarApp: boolean;
+    youtubeVideoId: string;
+    videoTitle?: string;
+    durationSeconds?: number;
+    existingMarkersCount: number;
+    message: string;
+}
+export declare function validateScholarVideoAccess(youtubeVideoId: string): ScholarProjectValidation;
+export declare function getCurrentScholarProject(): ScholarProjectValidation | null;
+export interface VerifiedCitationResult {
+    isVerified: boolean;
+    bookTitle?: string;
+    pageNumber?: number;
+    exactDbText?: string;
+    footnote?: string;
+    timestampSeconds: number;
+    speakerClaim: string;
+    verificationStatus: "AUTHENTIC_MATCH_FOUND" | "NO_EXACT_MATCH_IN_LOCAL_DB";
+}
+export declare function verifyCitationAgainstDb(bookIdentifier: string, searchPhrase: string, timestampSeconds: number, speakerClaim: string): VerifiedCitationResult;
+export declare function syncTimelineToScholarApp(youtubeVideoId: string, videoTitle: string, markers: Array<{
+    timestampSeconds: number;
+    referenceTitle: string;
+    exactText: string;
+    pageOrHadithNo?: string | number;
+}>): {
+    success: boolean;
+    youtubeVideoId: string;
+    videoTitle: string;
+    markersAdded: number;
+    message: string;
+};
+export declare function getAppTimelineMarkers(youtubeVideoId: string): any;

package/dist/services.js

@@ -1,4 +1,5 @@
 import { discoveryEngine } from "./db.js";
+import crypto from "crypto";
 export function listInstalledBooks() {
     return discoveryEngine.getInstalledPackages();
 }
@@ -85,3 +86,139 @@ export function getBookPage(packageIdOrFile, pageNumber) {
         footnote: row.fnotes,
     };
 }
+export function validateScholarVideoAccess(youtubeVideoId) {
+    const appDb = discoveryEngine.getAppDb();
+    if (!appDb) {
+        throw new Error("Daleel Scholar App database (app.db) not accessible. Please ensure Daleel Scholar App is installed.");
+    }
+    const draftStmt = appDb.prepare(`
+    SELECT youtube_video_id, video_title, duration_seconds
+    FROM timeline_drafts
+    WHERE youtube_video_id = ?
+    LIMIT 1
+  `);
+    const draft = draftStmt.get(youtubeVideoId);
+    if (!draft) {
+        return {
+            isRegisteredInScholarApp: false,
+            youtubeVideoId,
+            existingMarkersCount: 0,
+            message: `Access Denied: Video "${youtubeVideoId}" is not registered in your Daleel Scholar App. Please open or link this video inside Daleel Scholar App first before asking AI to verify citations.`,
+        };
+    }
+    const countStmt = appDb.prepare(`
+    SELECT COUNT(*) as count
+    FROM timeline_markers
+    WHERE youtube_video_id = ?
+  `);
+    const countRow = countStmt.get(youtubeVideoId);
+    return {
+        isRegisteredInScholarApp: true,
+        youtubeVideoId: draft.youtube_video_id,
+        videoTitle: draft.video_title,
+        durationSeconds: draft.duration_seconds,
+        existingMarkersCount: countRow?.count ?? 0,
+        message: `Access Verified: Video "${draft.video_title}" is active in Daleel Scholar workspace.`,
+    };
+}
+export function getCurrentScholarProject() {
+    const appDb = discoveryEngine.getAppDb();
+    if (!appDb)
+        return null;
+    try {
+        const stmt = appDb.prepare(`
+      SELECT youtube_video_id, video_title, duration_seconds
+      FROM timeline_drafts
+      ORDER BY updated_at DESC
+      LIMIT 1
+    `);
+        const row = stmt.get();
+        if (!row)
+            return null;
+        const countStmt = appDb.prepare(`
+      SELECT COUNT(*) as count FROM timeline_markers WHERE youtube_video_id = ?
+    `);
+        const countRow = countStmt.get(row.youtube_video_id);
+        return {
+            isRegisteredInScholarApp: true,
+            youtubeVideoId: row.youtube_video_id,
+            videoTitle: row.video_title,
+            durationSeconds: row.duration_seconds,
+            existingMarkersCount: countRow?.count ?? 0,
+            message: `Active Video in Scholar App: "${row.video_title}"`,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function verifyCitationAgainstDb(bookIdentifier, searchPhrase, timestampSeconds, speakerClaim) {
+    try {
+        const matches = searchInBook(bookIdentifier, searchPhrase, 1);
+        if (matches.length > 0) {
+            const best = matches[0];
+            return {
+                isVerified: true,
+                bookTitle: best.bookTitle,
+                pageNumber: best.pageNumber,
+                exactDbText: best.content,
+                footnote: best.footnote,
+                timestampSeconds,
+                speakerClaim,
+                verificationStatus: "AUTHENTIC_MATCH_FOUND",
+            };
+        }
+    }
+    catch (e) {
+        // book not found or search failed
+    }
+    return {
+        isVerified: false,
+        timestampSeconds,
+        speakerClaim,
+        verificationStatus: "NO_EXACT_MATCH_IN_LOCAL_DB",
+    };
+}
+export function syncTimelineToScholarApp(youtubeVideoId, videoTitle, markers) {
+    // First gatekeeper check: video must be valid
+    const validation = validateScholarVideoAccess(youtubeVideoId);
+    if (!validation.isRegisteredInScholarApp) {
+        throw new Error(validation.message);
+    }
+    const appDb = discoveryEngine.getAppDb();
+    if (!appDb) {
+        throw new Error("Daleel Scholar App database (app.db) not accessible.");
+    }
+    const insertMarker = appDb.prepare(`
+    INSERT INTO timeline_markers (id, youtube_video_id, timestamp_seconds, note, created_at, updated_at)
+    VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `);
+    let addedCount = 0;
+    for (const m of markers) {
+        const markerId = crypto.randomUUID();
+        const formattedNote = `[Verified Daleel Citation]\nBook: ${m.referenceTitle}\nRef/Page: ${m.pageOrHadithNo || 'N/A'}\nVerbatim Text:\n"${m.exactText.trim()}"`;
+        insertMarker.run(markerId, youtubeVideoId, m.timestampSeconds, formattedNote);
+        addedCount++;
+    }
+    // Update draft timestamp
+    appDb.prepare(`UPDATE timeline_drafts SET updated_at = CURRENT_TIMESTAMP WHERE youtube_video_id = ?`).run(youtubeVideoId);
+    return {
+        success: true,
+        youtubeVideoId,
+        videoTitle,
+        markersAdded: addedCount,
+        message: "Timeline markers successfully synchronized with Daleel Scholar Desktop (Tauri).",
+    };
+}
+export function getAppTimelineMarkers(youtubeVideoId) {
+    const appDb = discoveryEngine.getAppDb();
+    if (!appDb)
+        return [];
+    const stmt = appDb.prepare(`
+    SELECT id, youtube_video_id, timestamp_seconds, note, created_at
+    FROM timeline_markers
+    WHERE youtube_video_id = ?
+    ORDER BY timestamp_seconds ASC
+  `);
+    return stmt.all(youtubeVideoId);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "daleel-mcp",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Zero-data Model Context Protocol (MCP) server for Daleel Islamic Scholar App",
   "type": "module",
   "main": "dist/index.js",