@khoinguyen2002/doc-mcp 1.0.0

package/dist/config.d.ts

@@ -0,0 +1,13 @@
+export declare const config: {
+    QDRANT_URL: string;
+    OPENROUTER_API_KEY: string;
+    EMBEDDING_MODEL_ID: string;
+    CHUNK_SIZE: number;
+    CHUNK_OVERLAP: number;
+    DOC_MCP_DRIVE_FOLDER_ID?: string | undefined;
+    DOC_MCP_GOOGLE_CLIENT_EMAIL?: string | undefined;
+    DOC_MCP_GOOGLE_PRIVATE_KEY?: string | undefined;
+    QDRANT_API_KEY?: string | undefined;
+};
+export type Config = typeof config;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,MAAM;;;;;;;;;;CAAe,CAAC;AACnC,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC"}

package/dist/config.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+const schema = z.object({
+    DOC_MCP_DRIVE_FOLDER_ID: z.string().optional(),
+    DOC_MCP_GOOGLE_CLIENT_EMAIL: z.string().email().optional(),
+    DOC_MCP_GOOGLE_PRIVATE_KEY: z.string().optional(),
+    // Vector DB / Embeddings
+    QDRANT_URL: z.string().url().describe("The URL of your Qdrant instance"),
+    QDRANT_API_KEY: z.string().optional().describe("API Key for Qdrant Cloud (optional for local)"),
+    OPENROUTER_API_KEY: z.string().min(1),
+    EMBEDDING_MODEL_ID: z.string().default("nvidia/llama-nemotron-embed-vl-1b-v2:free"),
+    CHUNK_SIZE: z.coerce.number().int().positive().default(4000),
+    CHUNK_OVERLAP: z.coerce.number().int().nonnegative().default(500),
+});
+function loadConfig() {
+    const result = schema.safeParse(process.env);
+    if (!result.success) {
+        const missing = result.error.issues
+            .map((i) => `  ${i.path.join(".")}: ${i.message}`)
+            .join("\n");
+        throw new Error(`Invalid environment configuration for doc-mcp:\n${missing}`);
+    }
+    return result.data;
+}
+export const config = loadConfig();

package/dist/db/vector.d.ts

@@ -0,0 +1,8 @@
+export declare function initVectorDB(): Promise<void>;
+export declare function embedText(text: string): Promise<number[]>;
+export declare function upsertProjectDocument(projectId: string, text: string, metadata?: Record<string, any>): Promise<void>;
+export declare function searchProjectMemory(projectId: string, query: string, topK?: number): Promise<any[]>;
+export declare function deleteProjectDocument(projectId: string, fileId: string): Promise<void>;
+export declare function checkProjectDocumentExists(projectId: string, fileId: string): Promise<boolean>;
+export declare function getProjectDocumentMetadata(projectId: string): Promise<Record<string, string>>;
+//# sourceMappingURL=vector.d.ts.map

package/dist/db/vector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../src/db/vector.ts"],"names":[],"mappings":"AAOA,wBAAsB,YAAY,kBAqCjC;AAED,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAwB/D;AAED,wBAAsB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA0B9H;AAED,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,MAAU,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CA4B5G;AAED,wBAAsB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAa5F;AAED,wBAAsB,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAapG;AAED,wBAAsB,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAwBnG"}

package/dist/db/vector.js

@@ -0,0 +1,166 @@
+import { QdrantClient } from '@qdrant/js-client-rest';
+import { v4 as uuidv4 } from 'uuid';
+import { config } from '../config.js';
+let client = null;
+const COLLECTION_NAME = 'project_memory';
+export async function initVectorDB() {
+    if (!client) {
+        client = new QdrantClient({
+            url: config.QDRANT_URL,
+            apiKey: config.QDRANT_API_KEY,
+        });
+        console.error(`Connected to Qdrant at ${config.QDRANT_URL}`);
+        // Check if collection exists
+        const res = await client.getCollections();
+        const exists = res.collections.some(c => c.name === COLLECTION_NAME);
+        if (!exists) {
+            console.error(`Creating Qdrant collection: ${COLLECTION_NAME}`);
+            const dummyVector = await embedText("test");
+            const dimension = dummyVector.length;
+            await client.createCollection(COLLECTION_NAME, {
+                vectors: {
+                    size: dimension,
+                    distance: "Cosine",
+                },
+            });
+            await client.createPayloadIndex(COLLECTION_NAME, {
+                field_name: "projectId",
+                field_schema: "keyword",
+            });
+            await client.createPayloadIndex(COLLECTION_NAME, {
+                field_name: "file_id",
+                field_schema: "keyword",
+            });
+            await client.createPayloadIndex(COLLECTION_NAME, {
+                field_name: "source",
+                field_schema: "keyword",
+            });
+            console.error(`Collection ${COLLECTION_NAME} created with dimension ${dimension}.`);
+        }
+    }
+}
+export async function embedText(text) {
+    const response = await fetch("https://openrouter.ai/api/v1/embeddings", {
+        method: "POST",
+        headers: {
+            "Authorization": `Bearer ${config.OPENROUTER_API_KEY}`,
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+            model: config.EMBEDDING_MODEL_ID,
+            input: text
+        })
+    });
+    if (!response.ok) {
+        const errText = await response.text();
+        throw new Error(`OpenRouter Embedding API failed: ${response.status} ${errText}`);
+    }
+    const json = await response.json();
+    if (!json.data || !json.data[0] || !json.data[0].embedding) {
+        throw new Error("Invalid response from OpenRouter Embedding API");
+    }
+    return json.data[0].embedding;
+}
+export async function upsertProjectDocument(projectId, text, metadata = {}) {
+    await initVectorDB();
+    if (!client)
+        throw new Error("Qdrant not initialized");
+    const vector = await embedText(text);
+    await client.upsert(COLLECTION_NAME, {
+        wait: true,
+        points: [
+            {
+                id: uuidv4(),
+                vector: vector,
+                payload: {
+                    projectId,
+                    text,
+                    source: metadata.source || "user",
+                    file_id: metadata.file_id || null,
+                    modified_time: metadata.modified_time || null,
+                    metadata: JSON.stringify(metadata),
+                    createdAt: new Date().toISOString()
+                }
+            }
+        ]
+    });
+    console.error(`Upserted document chunk for project ${projectId}`);
+}
+export async function searchProjectMemory(projectId, query, topK = 3) {
+    await initVectorDB();
+    if (!client)
+        throw new Error("Qdrant not initialized");
+    const queryVector = await embedText(query);
+    const results = await client.search(COLLECTION_NAME, {
+        vector: queryVector,
+        limit: topK,
+        with_payload: true,
+        filter: {
+            must: [
+                {
+                    key: "projectId",
+                    match: {
+                        value: projectId
+                    }
+                }
+            ]
+        }
+    });
+    // Map to match LanceDB format expected by other tools
+    return results.map(r => ({
+        id: r.id,
+        vector: r.vector,
+        ...r.payload
+    }));
+}
+export async function deleteProjectDocument(projectId, fileId) {
+    await initVectorDB();
+    if (!client)
+        return;
+    await client.delete(COLLECTION_NAME, {
+        filter: {
+            must: [
+                { key: "projectId", match: { value: projectId } },
+                { key: "file_id", match: { value: fileId } }
+            ]
+        }
+    });
+    console.error(`Deleted old chunks from Qdrant for ${projectId} / ${fileId}`);
+}
+export async function checkProjectDocumentExists(projectId, fileId) {
+    await initVectorDB();
+    if (!client)
+        return false;
+    const res = await client.count(COLLECTION_NAME, {
+        filter: {
+            must: [
+                { key: "projectId", match: { value: projectId } },
+                { key: "file_id", match: { value: fileId } }
+            ]
+        }
+    });
+    return res.count > 0;
+}
+export async function getProjectDocumentMetadata(projectId) {
+    await initVectorDB();
+    if (!client)
+        return {};
+    const res = await client.scroll(COLLECTION_NAME, {
+        filter: {
+            must: [
+                { key: "projectId", match: { value: projectId } },
+                { key: "source", match: { value: "google_drive" } }
+            ]
+        },
+        limit: 10000,
+        with_payload: ["file_id", "modified_time"],
+        with_vector: false
+    });
+    const fileMap = {};
+    for (const r of res.points) {
+        if (r.payload && r.payload.file_id && r.payload.modified_time) {
+            fileMap[r.payload.file_id] = r.payload.modified_time;
+        }
+    }
+    return fileMap;
+}

package/dist/hooks/driveSync.d.ts

@@ -0,0 +1,2 @@
+export declare function syncProjectDriveFiles(projectId: string, onSyncMessage?: (msg: string) => void): Promise<void>;
+//# sourceMappingURL=driveSync.d.ts.map

package/dist/hooks/driveSync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"driveSync.d.ts","sourceRoot":"","sources":["../../src/hooks/driveSync.ts"],"names":[],"mappings":"AAeA,wBAAsB,qBAAqB,CACzC,SAAS,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GACpC,OAAO,CAAC,IAAI,CAAC,CAyFf"}

package/dist/hooks/driveSync.js

@@ -0,0 +1,88 @@
+import { getProjectDocumentMetadata, deleteProjectDocument, upsertProjectDocument, } from "../db/vector.js";
+import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
+// Remove childLogger dependency to fully decouple from core
+// import { childLogger } from "@workspace/core";
+import { config } from "../config.js";
+const log = {
+    info: (obj, msg) => console.log(`[driveSync] ${msg}`, obj),
+    error: (obj, msg) => console.error(`[driveSync] ${msg}`, obj)
+};
+export async function syncProjectDriveFiles(projectId, onSyncMessage) {
+    const dbMeta = await getProjectDocumentMetadata(projectId);
+    const fileIds = Object.keys(dbMeta);
+    if (fileIds.length === 0)
+        return;
+    log.info({ projectId, fileCount: fileIds.length }, "Checking Drive files for updates...");
+    const { google } = await import("googleapis");
+    const clientEmail = config.DOC_MCP_GOOGLE_CLIENT_EMAIL;
+    let privateKey = config.DOC_MCP_GOOGLE_PRIVATE_KEY;
+    if (!clientEmail || !privateKey)
+        return;
+    if (privateKey.startsWith('"') && privateKey.endsWith('"')) {
+        privateKey = privateKey.slice(1, -1);
+    }
+    privateKey = privateKey.replace(/\\n/g, "\n");
+    const auth = new google.auth.JWT({
+        email: clientEmail,
+        key: privateKey,
+        scopes: ["https://www.googleapis.com/auth/drive.readonly"],
+    });
+    const drive = google.drive({ version: "v3", auth });
+    let updatedCount = 0;
+    for (const fileId of fileIds) {
+        try {
+            const fileInfo = await drive.files.get({
+                fileId: fileId,
+                fields: "id, name, modifiedTime, trashed",
+                supportsAllDrives: true,
+            });
+            if (fileInfo.data.trashed) {
+                log.info({ fileId, projectId }, "File trashed on Drive, deleting from VectorDB...");
+                await deleteProjectDocument(projectId, fileId);
+                continue;
+            }
+            const driveModifiedTime = fileInfo.data.modifiedTime || "";
+            const dbModifiedTime = dbMeta[fileId];
+            if (driveModifiedTime !== dbModifiedTime) {
+                if (onSyncMessage) {
+                    onSyncMessage(`🔄 Syncing updated file: ${fileInfo.data.name}...`);
+                }
+                log.info({ fileId, projectId }, "File updated on Drive, syncing...");
+                await deleteProjectDocument(projectId, fileId);
+                const res = await drive.files.export({
+                    fileId: fileId,
+                    mimeType: "text/plain",
+                });
+                const content = res.data;
+                if (typeof content === "string" && content.trim() !== "") {
+                    const splitter = new RecursiveCharacterTextSplitter({
+                        chunkSize: config.CHUNK_SIZE,
+                        chunkOverlap: config.CHUNK_OVERLAP,
+                    });
+                    const chunks = await splitter.splitText(content);
+                    for (const chunk of chunks) {
+                        await upsertProjectDocument(projectId, chunk, {
+                            title: fileInfo.data.name,
+                            file_id: fileId,
+                            source: "google_drive",
+                            modified_time: driveModifiedTime,
+                        });
+                    }
+                    updatedCount++;
+                }
+            }
+        }
+        catch (err) {
+            if (err.code === 404) {
+                log.info({ fileId, projectId }, "File not found on Drive, deleting from VectorDB...");
+                await deleteProjectDocument(projectId, fileId);
+            }
+            else {
+                log.error({ fileId, err: err.message }, "Error syncing drive file");
+            }
+        }
+    }
+    if (updatedCount > 0 && onSyncMessage) {
+        onSyncMessage(`✅ Synced ${updatedCount} files from Google Drive.`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,4 @@
+export {};
+// The doc-agent is now an MCP Server.
+// Use `npx doc-agent` or `node dist/mcp-server.js` to run it.
+// We no longer export tools directly as JS functions.

package/dist/mcp-server.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=mcp-server.d.ts.map

package/dist/mcp-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../src/mcp-server.ts"],"names":[],"mappings":""}

package/dist/mcp-server.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { listDriveFiles, readDriveDocument, } from "./tools/driveTools.js";
+import { saveAgentNote, searchKnowledge } from "./tools/knowledgeTools.js";
+import { config } from "./config.js";
+const DRIVE_FOLDER_ID = config.DOC_MCP_DRIVE_FOLDER_ID;
+if (!DRIVE_FOLDER_ID) {
+    console.error("Missing DOC_MCP_DRIVE_FOLDER_ID environment variable. The doc-agent requires a target folder ID.");
+    process.exit(1);
+}
+const server = new McpServer({
+    name: "doc-agent",
+    version: "1.0.0",
+});
+// Register tools
+server.registerTool("list_drive_files", {
+    description: "List and search for Google Drive documents in the configured folder.",
+    inputSchema: {
+        keyword: z
+            .string()
+            .optional()
+            .describe("Optional keyword to search for in document titles"),
+    },
+}, async ({ keyword }) => {
+    const res = await listDriveFiles(keyword);
+    if (!res.success) {
+        return {
+            content: [{ type: "text", text: `Error: ${res.error}` }],
+            isError: true,
+        };
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify(res.results, null, 2) }],
+    };
+});
+server.registerTool("read_drive_document", {
+    description: "Read the content of a specific Google Drive document. The document will also be automatically ingested into vector memory for future semantic search.",
+    inputSchema: {
+        fileId: z.string().describe("The Google Drive file ID to read"),
+    },
+}, async ({ fileId }) => {
+    const res = await readDriveDocument(fileId);
+    if (!res.success) {
+        return {
+            content: [{ type: "text", text: `Error: ${res.error}` }],
+            isError: true,
+        };
+    }
+    return {
+        content: [{ type: "text", text: res.content || "No content found." }],
+    };
+});
+server.registerTool("save_agent_note", {
+    description: "Save an agent note, thought, or summary directly into the vector memory.",
+    inputSchema: {
+        content: z.string().describe("The note or knowledge content to store"),
+    },
+}, async ({ content }) => {
+    const res = await saveAgentNote(content);
+    if (!res.success) {
+        return {
+            content: [{ type: "text", text: `Error: ${res.error}` }],
+            isError: true,
+        };
+    }
+    return {
+        content: [{ type: "text", text: res.message || "Saved successfully" }],
+    };
+});
+server.registerTool("search_knowledge", {
+    description: "Search the folder's vector memory for relevant context or knowledge.",
+    inputSchema: {
+        query: z.string().describe("The search query"),
+        topK: z
+            .number()
+            .optional()
+            .describe("Number of results to return (default: 3)"),
+    },
+}, async ({ query, topK }) => {
+    const res = await searchKnowledge(query, topK);
+    if (!res.success) {
+        return {
+            content: [{ type: "text", text: `Error: ${res.error}` }],
+            isError: true,
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: typeof res.results === "string"
+                    ? res.results
+                    : JSON.stringify(res.results),
+            },
+        ],
+    };
+});
+// Start the server
+async function run() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("doc-agent MCP server running on stdio");
+}
+run().catch((error) => {
+    console.error("Fatal error running server:", error);
+    process.exit(1);
+});

package/dist/tools/driveTools.d.ts

@@ -0,0 +1,35 @@
+export declare function listDriveFiles(keyword?: string): Promise<{
+    success: boolean;
+    results: import("googleapis").drive_v3.Schema$File[];
+    error?: undefined;
+} | {
+    success: boolean;
+    error: any;
+    results?: undefined;
+}>;
+export declare function syncSingleDocument(fileId: string, folderId: string): Promise<{
+    synced: boolean;
+    content: string;
+    driveModifiedTime: string;
+} | {
+    synced: boolean;
+    driveModifiedTime: string;
+    content?: undefined;
+}>;
+export declare function readDriveDocument(fileId: string): Promise<{
+    success: boolean;
+    content: string;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: any;
+    content?: undefined;
+}>;
+export declare function syncFolderState(folderId: string): Promise<{
+    success: boolean;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: any;
+}>;
+//# sourceMappingURL=driveTools.d.ts.map

package/dist/tools/driveTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"driveTools.d.ts","sourceRoot":"","sources":["../../src/tools/driveTools.ts"],"names":[],"mappings":"AAiCA,wBAAsB,cAAc,CAAC,OAAO,CAAC,EAAE,MAAM;;;;;;;;GAoCpD;AAED,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;GA6CxE;AAED,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,MAAM;;;;;;;;GAsCrD;AAED,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM;;;;;;GAuCrD"}

package/dist/tools/driveTools.js

@@ -0,0 +1,166 @@
+import { google } from "googleapis";
+import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
+import { config } from "../config.js";
+import { upsertProjectDocument, getProjectDocumentMetadata, deleteProjectDocument, } from "../db/vector.js";
+function getDriveClient() {
+    const clientEmail = config.DOC_MCP_GOOGLE_CLIENT_EMAIL;
+    let privateKey = config.DOC_MCP_GOOGLE_PRIVATE_KEY;
+    if (!clientEmail || !privateKey) {
+        throw new Error("Google Drive credentials not configured. Please set DOC_MCP_GOOGLE_CLIENT_EMAIL and DOC_MCP_GOOGLE_PRIVATE_KEY in .env");
+    }
+    if (privateKey.startsWith('"') && privateKey.endsWith('"')) {
+        privateKey = privateKey.slice(1, -1);
+    }
+    privateKey = privateKey.replace(/\\n/g, "\n");
+    const auth = new google.auth.JWT({
+        email: clientEmail,
+        key: privateKey,
+        scopes: ["https://www.googleapis.com/auth/drive.readonly"],
+    });
+    return google.drive({ version: "v3", auth });
+}
+export async function listDriveFiles(keyword) {
+    const folderId = process.env.DOC_MCP_DRIVE_FOLDER_ID;
+    if (!folderId) {
+        return {
+            success: false,
+            error: "DOC_MCP_DRIVE_FOLDER_ID is not configured for this agent.",
+        };
+    }
+    try {
+        const drive = getDriveClient();
+        let q = "mimeType = 'application/vnd.google-apps.document'";
+        q = `'${folderId}' in parents and ${q}`;
+        if (keyword) {
+            q = `name contains '${keyword}' and ${q}`;
+        }
+        const res = await drive.files.list({
+            q,
+            fields: "files(id, name, description)",
+            spaces: "drive",
+            pageSize: 50,
+            supportsAllDrives: true,
+            includeItemsFromAllDrives: true,
+        });
+        const files = res.data.files;
+        if (!files || files.length === 0) {
+            return { success: true, results: [] };
+        }
+        return { success: true, results: files };
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+}
+export async function syncSingleDocument(fileId, folderId) {
+    const drive = getDriveClient();
+    const fileInfo = await drive.files.get({
+        fileId,
+        fields: "id, name, modifiedTime",
+        supportsAllDrives: true,
+    });
+    const driveModifiedTime = fileInfo.data.modifiedTime || "";
+    const dbMetaMap = await getProjectDocumentMetadata(folderId);
+    const dbModifiedTime = dbMetaMap[fileId];
+    if (!dbModifiedTime || dbModifiedTime !== driveModifiedTime) {
+        if (dbModifiedTime) {
+            await deleteProjectDocument(folderId, fileId);
+        }
+        const res = await drive.files.export({
+            fileId: fileId,
+            mimeType: "text/plain",
+        });
+        const content = res.data;
+        if (typeof content !== "string" || content.trim() === "") {
+            throw new Error("Empty or invalid file content");
+        }
+        const splitter = new RecursiveCharacterTextSplitter({
+            chunkSize: config.CHUNK_SIZE,
+            chunkOverlap: config.CHUNK_OVERLAP,
+        });
+        const chunks = await splitter.splitText(content);
+        for (const chunk of chunks) {
+            await upsertProjectDocument(folderId, chunk, {
+                title: fileInfo.data.name || "Untitled Google Doc",
+                source: "google_drive",
+                file_id: fileId,
+                modified_time: driveModifiedTime,
+            });
+        }
+        return { synced: true, content, driveModifiedTime };
+    }
+    return { synced: false, driveModifiedTime };
+}
+export async function readDriveDocument(fileId) {
+    const folderId = process.env.DOC_MCP_DRIVE_FOLDER_ID;
+    if (!folderId) {
+        return {
+            success: false,
+            error: "DOC_MCP_DRIVE_FOLDER_ID is not configured for this agent.",
+        };
+    }
+    try {
+        const result = await syncSingleDocument(fileId, folderId);
+        // If not synced just now, we need to fetch content to return to the user
+        let content = result.content;
+        if (!content) {
+            const drive = getDriveClient();
+            const res = await drive.files.export({
+                fileId: fileId,
+                mimeType: "text/plain",
+            });
+            content = typeof res.data === "string" ? res.data : "";
+        }
+        let finalContent = content;
+        const MAX_CHARS = 10000;
+        if (finalContent && finalContent.length > MAX_CHARS) {
+            finalContent =
+                finalContent.substring(0, MAX_CHARS) +
+                    "\n\n... [Content truncated due to length. The full document has been automatically ingested into Vector Memory. Use search_knowledge to query specific details.]";
+        }
+        return {
+            success: true,
+            content: finalContent || "Empty file",
+        };
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+}
+export async function syncFolderState(folderId) {
+    try {
+        const drive = getDriveClient();
+        let q = "mimeType = 'application/vnd.google-apps.document'";
+        q = `'${folderId}' in parents and ${q}`;
+        const res = await drive.files.list({
+            q,
+            fields: "files(id, name, modifiedTime)",
+            spaces: "drive",
+            pageSize: 100,
+            supportsAllDrives: true,
+            includeItemsFromAllDrives: true,
+        });
+        const driveFiles = res.data.files || [];
+        const dbMetaMap = await getProjectDocumentMetadata(folderId);
+        // Sync updated or new files
+        for (const file of driveFiles) {
+            if (!file.id)
+                continue;
+            const dbModTime = dbMetaMap[file.id];
+            if (!dbModTime || dbModTime !== file.modifiedTime) {
+                await syncSingleDocument(file.id, folderId);
+            }
+        }
+        // Delete removed files from DB
+        for (const dbFileId of Object.keys(dbMetaMap)) {
+            if (!driveFiles.find(f => f.id === dbFileId)) {
+                await deleteProjectDocument(folderId, dbFileId);
+            }
+        }
+        return { success: true };
+    }
+    catch (err) {
+        console.error("Auto-sync failed:", err.message);
+        return { success: false, error: err.message };
+    }
+}

package/dist/tools/knowledgeTools.d.ts

@@ -0,0 +1,19 @@
+export declare function saveAgentNote(content: string): Promise<{
+    success: boolean;
+    error: string;
+    message?: undefined;
+} | {
+    success: boolean;
+    message: string;
+    error?: undefined;
+}>;
+export declare function searchKnowledge(query: string, topK?: number): Promise<{
+    success: boolean;
+    error: string;
+    results?: undefined;
+} | {
+    success: boolean;
+    results: string;
+    error?: undefined;
+}>;
+//# sourceMappingURL=knowledgeTools.d.ts.map

package/dist/tools/knowledgeTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledgeTools.d.ts","sourceRoot":"","sources":["../../src/tools/knowledgeTools.ts"],"names":[],"mappings":"AAGA,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM;;;;;;;;GAelD;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,MAAU;;;;;;;;GAuBpE"}