@piotr-agier/google-drive-mcp 1.7.2 → 1.7.4

package/README.md

@@ -240,13 +240,20 @@ Add this configuration to use the Docker container with Claude Desktop:
 
 The server supports multiple methods for providing OAuth credentials (in order of priority):
 
-#### 1. **Environment Variable** (Recommended)
+#### 1. **Environment Variable** (Highest Priority)
 ```bash
 export GOOGLE_DRIVE_OAUTH_CREDENTIALS="/path/to/your/gcp-oauth.keys.json"
 ```
 
-#### 2. **Default File Location**
-Place `gcp-oauth.keys.json` in the project root directory
+#### 2. **Config Directory** (Recommended)
+Place `gcp-oauth.keys.json` in the XDG config directory:
+```
+~/.config/google-drive-mcp/gcp-oauth.keys.json
+```
+This is the recommended location — it works reliably with `npx`, global installs, and local setups.
+
+#### 3. **Project Root** (Legacy Fallback)
+Place `gcp-oauth.keys.json` in the project root directory. This still works for local development but is unreliable with `npx` or global installs.
 
 ### OAuth Scope Configuration
 
@@ -580,11 +587,12 @@ Add the server to your Claude Desktop configuration:
   - `uploadToSameFolder`: Upload to same folder as document (optional, default: true)
 
 #### Comments
-- **listComments** - List all comments in a Google Document
+- **listComments** - List all comments in a Google Document with position context, character offsets, and full reply chains
   - `documentId`: Document ID
   - `includeDeleted`: Include deleted comments (optional, default: false)
   - `pageSize`: Max comments to return, 1-100 (optional, default: 100)
   - `pageToken`: Token for next page of results (optional)
+  - Returns surrounding context and Docs API character offsets for each comment using a two-tiered approach (Docs API text matching, DOCX export fallback for ambiguous matches)
 
 - **getComment** - Get a specific comment with its full thread of replies
   - `documentId`: Document ID
@@ -942,15 +950,15 @@ After revoking access, you'll need to re-authenticate the next time you use the
 #### "OAuth credentials not found"
 ```
 OAuth credentials not found. Please provide credentials using one of these methods:
-1. Environment variable:
+1. Config directory (recommended):
+   Place your gcp-oauth.keys.json file in: ~/.config/google-drive-mcp/
+2. Environment variable:
    export GOOGLE_DRIVE_OAUTH_CREDENTIALS="/path/to/gcp-oauth.keys.json"
-2. Default file path:
-   Place your gcp-oauth.keys.json file in the package root directory.
 ```
 
 **Solution:**
 - Download credentials from Google Cloud Console
-- Either set the environment variable or place the file in the project root
+- Place the file in `~/.config/google-drive-mcp/gcp-oauth.keys.json` (recommended), or set the environment variable
 - Ensure the file has proper read permissions
 
 #### "Authentication failed" or Browser doesn't open
@@ -1143,7 +1151,7 @@ npm run typecheck # Type checking without compilation
 - `npm run typecheck` - Run TypeScript type checking only
 - `npm run lint` - Run TypeScript type checking (alias for typecheck)
 - `npm run prepare` - Auto-runs build before npm publish
-- `npm test` - Run tests (placeholder - no tests implemented yet)
+- `npm test` - Run unit tests
 
 ## Advanced Configuration
 
@@ -1155,7 +1163,8 @@ npm run typecheck # Type checking without compilation
 | Variable | Description | Example |
 |----------|-------------|---------|
 | `GOOGLE_DRIVE_OAUTH_CREDENTIALS` | Path to your OAuth credentials JSON file | `/home/user/secrets/oauth.json` |
-| *(or place file at)* | Default location: `gcp-oauth.keys.json` in project root | `./gcp-oauth.keys.json` |
+| *(or place file at)* | Config directory (recommended): `~/.config/google-drive-mcp/gcp-oauth.keys.json` | `~/.config/google-drive-mcp/gcp-oauth.keys.json` |
+| *(or place file at)* | Project root (legacy fallback): `gcp-oauth.keys.json` | `./gcp-oauth.keys.json` |
 
 **Optional** (for customization):
 | Variable | Description | Default | Example |

package/dist/index.js

@@ -29,14 +29,16 @@ function getProjectRoot() {
   const projectRoot = path.join(__dirname2, "..", "..");
   return path.resolve(projectRoot);
 }
+function getConfigDir() {
+  const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+  return path.join(configHome, "google-drive-mcp");
+}
 function getSecureTokenPath() {
   const customTokenPath = process.env.GOOGLE_DRIVE_MCP_TOKEN_PATH;
   if (customTokenPath) {
     return path.resolve(customTokenPath);
   }
-  const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
-  const tokenDir = path.join(configHome, "google-drive-mcp");
-  return path.join(tokenDir, "tokens.json");
+  return path.join(getConfigDir(), "tokens.json");
 }
 function getLegacyTokenPath() {
   const projectRoot = getProjectRoot();
@@ -49,26 +51,29 @@ function getAdditionalLegacyPaths() {
     path.join(process.cwd(), ".gcp-saved-tokens.json")
   ].filter(Boolean);
 }
-function getKeysFilePath() {
+function getKeysFilePaths() {
+  const paths = [];
   const envCredentialsPath = process.env.GOOGLE_DRIVE_OAUTH_CREDENTIALS;
   if (envCredentialsPath) {
-    return path.resolve(envCredentialsPath);
+    paths.push(path.resolve(envCredentialsPath));
   }
+  paths.push(path.join(getConfigDir(), "gcp-oauth.keys.json"));
   const projectRoot = getProjectRoot();
-  const keysPath = path.join(projectRoot, "gcp-oauth.keys.json");
-  return keysPath;
+  paths.push(path.join(projectRoot, "gcp-oauth.keys.json"));
+  return paths;
 }
 function generateCredentialsErrorMessage() {
+  const configDir = getConfigDir();
   return `
 OAuth credentials not found. Please provide credentials using one of these methods:
 
-1. Environment variable:
+1. Config directory (recommended):
+   Place your gcp-oauth.keys.json file in: ${configDir}/
+
+2. Environment variable:
    Set GOOGLE_DRIVE_OAUTH_CREDENTIALS to the path of your credentials file:
    export GOOGLE_DRIVE_OAUTH_CREDENTIALS="/path/to/gcp-oauth.keys.json"
 
-2. Default file path:
-   Place your gcp-oauth.keys.json file in the package root directory.
-
 Token storage:
 - Tokens are saved to: ${getSecureTokenPath()}
 - To use a custom token location, set GOOGLE_DRIVE_MCP_TOKEN_PATH environment variable
@@ -83,9 +88,7 @@ To get OAuth credentials:
 }
 
 // src/auth/client.ts
-async function loadCredentialsFromFile() {
-  const keysContent = await fs.readFile(getKeysFilePath(), "utf-8");
-  const keys = JSON.parse(keysContent);
+function parseCredentialsFile(keys) {
   if (keys.installed) {
     const { client_id, client_secret, redirect_uris } = keys.installed;
     return { client_id, client_secret, redirect_uris };
@@ -102,6 +105,21 @@ async function loadCredentialsFromFile() {
     throw new Error('Invalid credentials file format. Expected either "installed", "web" object or direct client_id field.');
   }
 }
+async function loadCredentialsFromFile() {
+  const paths = getKeysFilePaths();
+  for (const keysPath of paths) {
+    try {
+      const keysContent = await fs.readFile(keysPath, "utf-8");
+      const keys = JSON.parse(keysContent);
+      return parseCredentialsFile(keys);
+    } catch (err) {
+      if (err instanceof SyntaxError || err instanceof Error && err.message.includes("Invalid credentials")) {
+        throw new Error(`Invalid credentials file at ${keysPath}: ${err.message}`);
+      }
+    }
+  }
+  throw new Error(`Credentials file not found. Searched: ${paths.join(", ")}`);
+}
 async function loadCredentialsWithFallback() {
   try {
     return await loadCredentialsFromFile();
@@ -2252,12 +2270,17 @@ ${JSON.stringify({ message }, null, 2)}` }],
 // src/tools/docs.ts
 var docs_exports = {};
 __export(docs_exports, {
+  buildFlatTextFromDoc: () => buildFlatTextFromDoc,
+  extractRowCells: () => extractRowCells,
   handleTool: () => handleTool2,
+  matchDocxToDriveComments: () => matchDocxToDriveComments,
+  resolveContextFromDocx: () => resolveContextFromDocx,
   toolDefinitions: () => toolDefinitions2
 });
 import { z as z2 } from "zod";
 import { createReadStream as createReadStream2, existsSync as existsSync3 } from "fs";
 import { basename as basename3, extname as extname3 } from "path";
+import JSZip from "jszip";
 function hexToRgbColor(hex) {
   if (!hex) return null;
   let hexClean = hex.startsWith("#") ? hex.slice(1) : hex;
@@ -2280,6 +2303,28 @@ function rgbColorToHex(color) {
   const b = Math.round((rgb.blue || 0) * 255);
   return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
 }
+function collectAllTabsWithLevel(tabs, level = 0) {
+  const result = [];
+  for (const tab of tabs) {
+    result.push({ tab, level });
+    if (tab.childTabs && tab.childTabs.length > 0) {
+      result.push(...collectAllTabsWithLevel(tab.childTabs, level + 1));
+    }
+  }
+  return result;
+}
+function findTabById(tabs, targetId) {
+  for (const tab of tabs) {
+    if (tab.tabProperties?.tabId === targetId) {
+      return tab;
+    }
+    if (tab.childTabs && tab.childTabs.length > 0) {
+      const found = findTabById(tab.childTabs, targetId);
+      if (found) return found;
+    }
+  }
+  return null;
+}
 async function executeBatchUpdate(ctx, documentId, requests) {
   if (!requests || requests.length === 0) {
     return {};
@@ -2589,6 +2634,236 @@ async function uploadImageToDriveHelper(ctx, localFilePath, parentFolderId, make
   }
   return webContentLink;
 }
+var MAX_ROW_XML_DISTANCE = 1e5;
+var MAX_PARAGRAPH_XML_DISTANCE = 5e4;
+var MAX_PARAGRAPH_CONTEXT_LENGTH = 300;
+function buildFlatTextFromDoc(docData) {
+  function extractSegments(bodyContent) {
+    const segs = [];
+    function fromElements(elements) {
+      for (const el of elements) {
+        if (el.textRun?.content && el.startIndex != null) {
+          segs.push({ text: el.textRun.content, startIndex: el.startIndex });
+        }
+      }
+    }
+    for (const el of bodyContent) {
+      if (el.paragraph?.elements) {
+        fromElements(el.paragraph.elements);
+      } else if (el.table) {
+        for (const row of el.table.tableRows || []) {
+          for (const cell of row.tableCells || []) {
+            for (const cc of cell.content || []) {
+              if (cc.paragraph?.elements) fromElements(cc.paragraph.elements);
+              if (cc.table) {
+                const nested = extractSegments([cc]);
+                segs.push(...nested);
+              }
+            }
+          }
+        }
+      }
+    }
+    return segs;
+  }
+  const allSegments = [];
+  const tabs = docData.tabs;
+  if (tabs && tabs.length > 0) {
+    for (const tab of tabs) {
+      const bc = tab.documentTab?.body?.content;
+      if (bc) allSegments.push(...extractSegments(bc));
+    }
+  } else if (docData.body?.content) {
+    allSegments.push(...extractSegments(docData.body.content));
+  }
+  let flatText = "";
+  const offsetMap = [];
+  for (const seg of allSegments) {
+    for (let i = 0; i < seg.text.length; i++) {
+      offsetMap.push(seg.startIndex + i);
+      flatText += seg.text[i];
+    }
+  }
+  return { flatText, offsetMap };
+}
+function extractRowCells(rowXml) {
+  const cells = [];
+  let searchFrom = 0;
+  while (true) {
+    const tcStart1 = rowXml.indexOf("<w:tc>", searchFrom);
+    const tcStart2 = rowXml.indexOf("<w:tc ", searchFrom);
+    const tcStart = tcStart1 === -1 && tcStart2 === -1 ? -1 : tcStart1 === -1 ? tcStart2 : tcStart2 === -1 ? tcStart1 : Math.min(tcStart1, tcStart2);
+    if (tcStart === -1) break;
+    const tcEnd = rowXml.indexOf("</w:tc>", tcStart);
+    if (tcEnd === -1) break;
+    const cellXml = rowXml.substring(tcStart, tcEnd);
+    const tTexts = [];
+    const tRegex = /<w:t[^>]*>([^<]*)<\/w:t>/g;
+    let t;
+    while ((t = tRegex.exec(cellXml)) !== null) tTexts.push(t[1]);
+    if (tTexts.length > 0) cells.push(tTexts.join(""));
+    searchFrom = tcEnd + 7;
+  }
+  return cells;
+}
+async function resolveContextFromDocx(docxData) {
+  const zip = await JSZip.loadAsync(docxData);
+  const commentsXml = await zip.file("word/comments.xml")?.async("string");
+  const documentXml = await zip.file("word/document.xml")?.async("string");
+  if (!commentsXml || !documentXml) return null;
+  const docxComments = /* @__PURE__ */ new Map();
+  const commentTagRegex = /<w:comment\s+[^>]*?w:id="(\d+)"[^>]*>/g;
+  let cMatch;
+  while ((cMatch = commentTagRegex.exec(commentsXml)) !== null) {
+    const id = parseInt(cMatch[1]);
+    const tagStr = cMatch[0];
+    const authorMatch = tagStr.match(/w:author="([^"]*)"/);
+    const dateMatch = tagStr.match(/w:date="([^"]*)"/);
+    const author = authorMatch ? authorMatch[1] : "";
+    const date = dateMatch ? dateMatch[1] : "";
+    const endPos = commentsXml.indexOf("</w:comment>", cMatch.index);
+    if (endPos !== -1) {
+      const body = commentsXml.substring(cMatch.index, endPos);
+      const texts = [];
+      const tRegex = /<w:t[^>]*>([^<]*)<\/w:t>/g;
+      let tMatch;
+      while ((tMatch = tRegex.exec(body)) !== null) {
+        texts.push(tMatch[1]);
+      }
+      docxComments.set(id, { author, date, content: texts.join("") });
+    }
+  }
+  const contextsBefore = /* @__PURE__ */ new Map();
+  const contextsAfter = /* @__PURE__ */ new Map();
+  const rowCells = /* @__PURE__ */ new Map();
+  const rangeStartRegex = /<w:commentRangeStart\s+w:id="(\d+)"\/>/g;
+  let rMatch;
+  while ((rMatch = rangeStartRegex.exec(documentXml)) !== null) {
+    const docxId = parseInt(rMatch[1]);
+    const startPos = rMatch.index;
+    const trStart = documentXml.lastIndexOf("<w:tr>", startPos);
+    const trEnd = documentXml.indexOf("</w:tr>", startPos);
+    if (trStart !== -1 && trEnd !== -1 && startPos - trStart < MAX_ROW_XML_DISTANCE) {
+      const rowXml = documentXml.substring(trStart, trEnd);
+      const cellTexts = extractRowCells(rowXml);
+      const commentMarker = `commentRangeStart w:id="${docxId}"`;
+      let commentCellIdx = -1;
+      let cellSearchFrom = 0;
+      for (let ci = 0; ci < cellTexts.length; ci++) {
+        const tcStart1 = rowXml.indexOf("<w:tc>", cellSearchFrom);
+        const tcStart2 = rowXml.indexOf("<w:tc ", cellSearchFrom);
+        const tcStart = tcStart1 === -1 && tcStart2 === -1 ? -1 : tcStart1 === -1 ? tcStart2 : tcStart2 === -1 ? tcStart1 : Math.min(tcStart1, tcStart2);
+        if (tcStart === -1) break;
+        const tcEnd = rowXml.indexOf("</w:tc>", tcStart);
+        if (tcEnd === -1) break;
+        const cellXml = rowXml.substring(tcStart, tcEnd);
+        if (cellXml.includes(commentMarker)) {
+          commentCellIdx = ci;
+        }
+        cellSearchFrom = tcEnd + 7;
+      }
+      if (cellTexts.length > 0) {
+        const allTexts = cellTexts;
+        rowCells.set(docxId, allTexts);
+        if (commentCellIdx !== -1) {
+          const before = cellTexts.slice(0, commentCellIdx);
+          let after = cellTexts.slice(commentCellIdx + 1);
+          if (commentCellIdx === cellTexts.length - 1) {
+            const nextTrStart = documentXml.indexOf("<w:tr>", trEnd);
+            const nextTrEnd = nextTrStart !== -1 ? documentXml.indexOf("</w:tr>", nextTrStart) : -1;
+            if (nextTrStart !== -1 && nextTrEnd !== -1) {
+              const nextRowXml = documentXml.substring(nextTrStart, nextTrEnd);
+              after = extractRowCells(nextRowXml);
+            }
+          }
+          const commentText = cellTexts[commentCellIdx];
+          contextsBefore.set(docxId, [...before, commentText].join(" | "));
+          contextsAfter.set(docxId, [commentText, ...after].join(" | "));
+        } else {
+          contextsBefore.set(docxId, allTexts.join(" | "));
+          contextsAfter.set(docxId, "");
+        }
+        continue;
+      }
+    }
+    const pStart = documentXml.lastIndexOf("<w:p ", startPos);
+    const pEnd = documentXml.indexOf("</w:p>", startPos);
+    if (pStart !== -1 && pEnd !== -1 && startPos - pStart < MAX_PARAGRAPH_XML_DISTANCE) {
+      const pXml = documentXml.substring(pStart, pEnd);
+      const pTexts = [];
+      const tRegex = /<w:t[^>]*>([^<]*)<\/w:t>/g;
+      let t;
+      while ((t = tRegex.exec(pXml)) !== null) pTexts.push(t[1]);
+      const pText = pTexts.join("").trim();
+      if (pText) {
+        contextsBefore.set(docxId, pText.length > MAX_PARAGRAPH_CONTEXT_LENGTH ? pText.substring(0, MAX_PARAGRAPH_CONTEXT_LENGTH) + "..." : pText);
+        contextsAfter.set(docxId, "");
+      }
+    }
+  }
+  return { docxComments, contextsBefore, contextsAfter, rowCells };
+}
+function matchDocxToDriveComments(driveComments, docxResult, contextMap, flatText, offsetMap) {
+  const { docxComments, contextsBefore, contextsAfter } = docxResult;
+  for (const comment of driveComments) {
+    if (contextMap.has(comment.id)) continue;
+    if (comment.resolved) continue;
+    const apiAuthor = comment.author?.displayName || "";
+    const apiDate = (comment.createdTime || "").replace(/\.\d+Z$/, "Z");
+    let matchedDocxId = null;
+    for (const [docxId, docxComment] of docxComments) {
+      if (docxComment.author === apiAuthor && docxComment.date === apiDate) {
+        matchedDocxId = docxId;
+        break;
+      }
+    }
+    if (matchedDocxId !== null) {
+      const ctxBefore = contextsBefore.get(matchedDocxId) || "";
+      const ctxAfter = contextsAfter.get(matchedDocxId) || "";
+      if (ctxBefore || ctxAfter) {
+        const entry = {
+          contextBefore: ctxBefore,
+          contextAfter: ctxAfter
+        };
+        const quoted = comment.quotedFileContent?.value;
+        if (quoted && flatText && offsetMap.length > 0 && ctxBefore) {
+          const beforePattern = ctxBefore.split(" | ").join("\n");
+          const findAll = (pattern) => {
+            const results = [];
+            let from = 0;
+            while (true) {
+              const idx = flatText.indexOf(pattern, from);
+              if (idx === -1) break;
+              results.push(idx);
+              from = idx + 1;
+            }
+            return results;
+          };
+          let matches = findAll(beforePattern);
+          if (matches.length !== 1 && ctxAfter) {
+            const afterCells = ctxAfter.split(" | ");
+            const afterWithoutAnchor = afterCells.slice(1).join("\n");
+            if (afterWithoutAnchor) {
+              const fullPattern = beforePattern + "\n" + afterWithoutAnchor;
+              matches = findAll(fullPattern);
+            }
+          }
+          if (matches.length === 1) {
+            const patternStart = matches[0];
+            const qIdx = patternStart + beforePattern.length - quoted.length;
+            const endIdx = qIdx + quoted.length - 1;
+            if (endIdx < offsetMap.length && flatText.substring(qIdx, qIdx + quoted.length) === quoted) {
+              entry.startIndex = offsetMap[qIdx];
+              entry.endIndex = offsetMap[endIdx] + 1;
+            }
+          }
+        }
+        contextMap.set(comment.id, entry);
+      }
+      docxComments.delete(matchedDocxId);
+    }
+  }
+}
 var CreateGoogleDocSchema = z2.object({
   name: z2.string().min(1, "Document name is required"),
   content: z2.string(),
@@ -3418,12 +3693,17 @@ Link: ${doc.webViewLink}` }],
       const tabs = document.data.tabs;
       let formattedContent = "Document content with indices:\n\n";
       let totalLength = 0;
-      if (tabs && tabs.length > 1) {
-        for (const tab of tabs) {
-          const title = tab.tabProperties?.title || "Untitled";
+      if (tabs && tabs.length > 0) {
+        const allTabs = collectAllTabsWithLevel(tabs);
+        const isMultiTab = allTabs.length > 1;
+        for (const { tab, level } of allTabs) {
           const bodyContent = tab.documentTab?.body?.content;
-          formattedContent += `=== Tab: ${title} ===
+          if (isMultiTab) {
+            const title = tab.tabProperties?.title || "Untitled";
+            const indent = "  ".repeat(level);
+            formattedContent += `${indent}=== Tab: ${title} ===
 `;
+          }
           if (bodyContent) {
             const segments = extractSegments2(bodyContent);
             trackFonts2(segments);
@@ -3432,15 +3712,9 @@ Link: ${doc.webViewLink}` }],
               totalLength += segments[segments.length - 1].endIndex;
             }
           }
-          formattedContent += "\n";
-        }
-      } else if (tabs && tabs.length === 1) {
-        const bodyContent = tabs[0].documentTab?.body?.content;
-        if (bodyContent) {
-          const segments = extractSegments2(bodyContent);
-          trackFonts2(segments);
-          formattedContent += formatSegments2(segments);
-          totalLength = segments.length > 0 ? segments[segments.length - 1].endIndex : 0;
+          if (isMultiTab) {
+            formattedContent += "\n";
+          }
         }
       } else {
         const bodyContent = document.data.body?.content;
@@ -3581,7 +3855,7 @@ Total length: ${totalLength} characters`
       const tabs = doc.tabs;
       if (tabs && tabs.length > 0) {
         if (a.tabId) {
-          const tab = tabs.find((t) => t.tabProperties?.tabId === a.tabId);
+          const tab = findTabById(tabs, a.tabId);
           if (!tab) {
             return errorResponse(`Tab with ID "${a.tabId}" not found. Use listDocumentTabs to see available tabs.`);
           }
@@ -3589,21 +3863,23 @@ Total length: ${totalLength} characters`
           if (bodyContent) {
             text = extractText2(bodyContent);
           }
-        } else if (tabs.length > 1) {
-          for (const tab of tabs) {
-            const title = tab.tabProperties?.title || "Untitled";
-            text += `=== Tab: ${title} ===
-`;
+        } else {
+          const allTabs = collectAllTabsWithLevel(tabs);
+          const isMultiTab = allTabs.length > 1;
+          for (const { tab, level } of allTabs) {
             const bodyContent = tab.documentTab?.body?.content;
+            if (isMultiTab) {
+              const title = tab.tabProperties?.title || "Untitled";
+              const indent = "  ".repeat(level);
+              text += `${indent}=== Tab: ${title} ===
+`;
+            }
             if (bodyContent) {
               text += extractText2(bodyContent);
             }
-            text += "\n";
-          }
-        } else {
-          const bodyContent = tabs[0].documentTab?.body?.content;
-          if (bodyContent) {
-            text = extractText2(bodyContent);
+            if (isMultiTab) {
+              text += "\n";
+            }
           }
         }
       } else {
@@ -3933,7 +4209,7 @@ ${text}`;
       const a = validation.data;
       const response = await ctx.getDrive().comments.list({
         fileId: a.documentId,
-        fields: "comments(id,content,quotedFileContent,author,createdTime,resolved,replies),nextPageToken",
+        fields: "comments(id,content,quotedFileContent,author,createdTime,resolved,replies(id,content,author,createdTime)),nextPageToken",
         pageSize: a.pageSize || 100,
         pageToken: a.pageToken,
         includeDeleted: a.includeDeleted || false
@@ -3946,18 +4222,124 @@ ${text}`;
           isError: false
         };
       }
+      const contextMap = /* @__PURE__ */ new Map();
+      let flatText = "";
+      let offsetMap = [];
+      let needsDocxFallback = false;
+      let isGoogleDoc = false;
+      try {
+        const fileInfo = await ctx.getDrive().files.get({
+          fileId: a.documentId,
+          fields: "mimeType",
+          supportsAllDrives: true
+        });
+        isGoogleDoc = fileInfo.data.mimeType === "application/vnd.google-apps.document";
+      } catch (err) {
+        ctx.log("Failed to check file MIME type:", err);
+      }
+      if (isGoogleDoc) {
+        try {
+          let getContext2 = function(matchStart, matchLen) {
+            const matchText = flatText.substring(matchStart, matchStart + matchLen);
+            const beforeStart = Math.max(0, matchStart - 120);
+            let before = flatText.substring(beforeStart, matchStart).trim();
+            if (beforeStart > 0) before = "..." + before;
+            before = before + matchText;
+            const afterEnd = Math.min(flatText.length, matchStart + matchLen + 120);
+            let after = flatText.substring(matchStart + matchLen, afterEnd).trim();
+            if (afterEnd < flatText.length) after = after + "...";
+            after = matchText + after;
+            return { before, after };
+          };
+          var getContext = getContext2;
+          const docs = ctx.google.docs({ version: "v1", auth: ctx.authClient });
+          const docResponse = await docs.documents.get({
+            documentId: a.documentId,
+            includeTabsContent: true
+          });
+          const result = buildFlatTextFromDoc(docResponse.data);
+          flatText = result.flatText;
+          offsetMap = result.offsetMap;
+          const ambiguousComments = [];
+          for (const comment of comments) {
+            const quoted = comment.quotedFileContent?.value;
+            if (!quoted) continue;
+            const positions = [];
+            let searchFrom = 0;
+            while (true) {
+              const idx = flatText.indexOf(quoted, searchFrom);
+              if (idx === -1) break;
+              positions.push(idx);
+              searchFrom = idx + 1;
+            }
+            if (positions.length === 1) {
+              const surrounding = getContext2(positions[0], quoted.length);
+              const entry = {
+                contextBefore: surrounding.before,
+                contextAfter: surrounding.after
+              };
+              const endIdx = positions[0] + quoted.length - 1;
+              if (endIdx < offsetMap.length) {
+                entry.startIndex = offsetMap[positions[0]];
+                entry.endIndex = offsetMap[endIdx] + 1;
+              }
+              if (comment.id) contextMap.set(comment.id, entry);
+            } else if (positions.length > 1) {
+              ambiguousComments.push(comment);
+            }
+          }
+          needsDocxFallback = ambiguousComments.length > 0;
+        } catch (err) {
+          ctx.log("Tier 1 context extraction failed:", err);
+          needsDocxFallback = true;
+        }
+      }
+      if (needsDocxFallback) {
+        const unresolved = comments.filter((c) => !contextMap.has(c.id) && !c.resolved);
+        if (unresolved.length > 0) {
+          try {
+            const docxResponse = await ctx.getDrive().files.export({
+              fileId: a.documentId,
+              mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+            }, { responseType: "arraybuffer" });
+            const docxResult = await resolveContextFromDocx(docxResponse.data);
+            if (docxResult) {
+              matchDocxToDriveComments(comments, docxResult, contextMap, flatText, offsetMap);
+            }
+          } catch (err) {
+            ctx.log("Tier 2 DOCX context extraction failed:", err);
+          }
+        }
+      }
       const formattedComments = comments.map((comment, index) => {
-        const replies = comment.replies?.length || 0;
         const status = comment.resolved ? " [RESOLVED]" : "";
         const author = comment.author?.displayName || "Unknown";
         const date = comment.createdTime ? new Date(comment.createdTime).toLocaleDateString() : "Unknown date";
-        const quotedText = comment.quotedFileContent?.value || "No quoted text";
-        const anchor = quotedText !== "No quoted text" ? ` (anchored to: "${quotedText.substring(0, 100)}${quotedText.length > 100 ? "..." : ""}")` : "";
-        let result = `${index + 1}. ${author} (${date})${status}${anchor}
-   ${comment.content}`;
-        if (replies > 0) {
-          result += `
-   \u2514\u2500 ${replies} ${replies === 1 ? "reply" : "replies"}`;
+        const quotedText = comment.quotedFileContent?.value;
+        const commentCtx = contextMap.get(comment.id);
+        let positionInfo = "";
+        const indexStr = commentCtx?.startIndex != null ? ` [chars ${commentCtx.startIndex}-${commentCtx.endIndex}]` : "";
+        if (quotedText) {
+          const snippet = quotedText.length > 100 ? quotedText.substring(0, 100) + "..." : quotedText;
+          positionInfo = `
+   Anchored to: "${snippet}"${indexStr}`;
+        }
+        if (commentCtx) {
+          if (commentCtx.contextBefore) positionInfo += `
+   Context before: "${commentCtx.contextBefore}"`;
+          if (commentCtx.contextAfter) positionInfo += `
+   Context after: "${commentCtx.contextAfter}"`;
+        }
+        let result = `${index + 1}. ${author} (${date})${status}${positionInfo}
+   Comment: ${comment.content}`;
+        if (comment.replies && comment.replies.length > 0) {
+          for (const reply of comment.replies) {
+            const replyAuthor = reply.author?.displayName || "Unknown";
+            const replyDate = reply.createdTime ? new Date(reply.createdTime).toLocaleDateString() : "Unknown date";
+            const replyContent = reply.content || "(empty)";
+            result += `
+   \u2514\u2500 ${replyAuthor} (${replyDate}): ${replyContent}`;
+          }
         }
         result += `
    Comment ID: ${comment.id}`;