@credal/actions 0.2.36 → 0.2.37

package/dist/actions/providers/google-oauth/searchDriveAndGetContentByKeywords.js

@@ -0,0 +1,110 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { axiosClient } from "../../util/axiosClient.js";
+import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
+import extractContentFromDriveFileId from "./utils/extractContentFromDriveFileId.js";
+import { normalizeText } from "../../../utils/string.js";
+/** Intelligently selects a section of text around the median occurrence of keywords */
+const intelligentSelectByMedianSection = (text, keywords, limit) => {
+    if (!text || text.length <= limit)
+        return text;
+    if (!(keywords === null || keywords === void 0 ? void 0 : keywords.length))
+        return text.substring(0, limit);
+    // Find all keyword positions (case-insensitive, limited to first 1000 matches)
+    const positions = [];
+    const normalizedText = normalizeText(text);
+    for (const keyword of keywords) {
+        if (keyword.length < 3)
+            continue; // Skip very short keywords
+        let pos = -1;
+        const normalizedKeyword = normalizeText(keyword);
+        while ((pos = normalizedText.indexOf(normalizedKeyword, pos + 1)) !== -1 && positions.length < 1000) {
+            positions.push(pos);
+        }
+    }
+    if (!positions.length)
+        return text.substring(0, limit);
+    // Find median position (using sort for simplicity, still fast for 1000 elements)
+    positions.sort((a, b) => a - b);
+    const medianPos = positions[Math.floor(positions.length / 2)];
+    // Return window around median
+    const half = Math.floor(limit / 2);
+    const start = Math.max(0, medianPos - half);
+    const end = Math.min(text.length, start + limit);
+    return text.substring(start, end);
+};
+const searchDriveAndGetContentByKeywords = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    var _b;
+    if (!authParams.authToken) {
+        return { success: false, error: MISSING_AUTH_TOKEN, files: [] };
+    }
+    const { keywords, fileLimit, fileSizeLimit } = params;
+    let files = [];
+    // 1. Search for files and get their metadata
+    // Build the query: fullText contains 'keyword1' or fullText contains 'keyword2' ...
+    const query = keywords.map(kw => `fullText contains '${kw.replace(/'/g, "\\'")}'`).join(" or ");
+    const url = `https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id,name,mimeType,webViewLink)&supportsAllDrives=true&includeItemsFromAllDrives=true`;
+    try {
+        const res = yield axiosClient.get(url, {
+            headers: {
+                Authorization: `Bearer ${authParams.authToken}`,
+            },
+        });
+        files =
+            ((_b = res.data.files) === null || _b === void 0 ? void 0 : _b.map((file) => ({
+                id: file.id,
+                name: file.name,
+                mimeType: file.mimeType,
+                url: file.webViewLink,
+            }))) || [];
+    }
+    catch (error) {
+        console.error("Error searching Google Drive", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+            files: [],
+        };
+    }
+    files = fileLimit ? files.splice(0, fileLimit) : files;
+    // 2. Extract content from files and do some smart range selection
+    const processedFiles = yield Promise.all(files
+        .filter((file) => file.id && file.mimeType)
+        .map((file) => __awaiter(void 0, void 0, void 0, function* () {
+        const content = yield extractContentFromDriveFileId({
+            params: { fileId: file.id, mimeType: file.mimeType },
+            authParams,
+        });
+        if (content.success) {
+            let selectedContent = content.content;
+            if (fileSizeLimit && selectedContent && selectedContent.length > fileSizeLimit) {
+                selectedContent = intelligentSelectByMedianSection(selectedContent, keywords, fileSizeLimit);
+            }
+            return {
+                id: file.id || "",
+                name: file.name || "",
+                mimeType: file.mimeType || "",
+                url: file.url || "",
+                content: selectedContent,
+            };
+        }
+        else {
+            return {
+                id: file.id || "",
+                name: file.name || "",
+                mimeType: file.mimeType || "",
+                url: file.url || "",
+                error: content.error,
+            };
+        }
+    })));
+    return { success: true, files: processedFiles };
+});
+export default searchDriveAndGetContentByKeywords;

package/dist/actions/providers/google-oauth/utils/extractContentFromDriveFileId.d.ts

@@ -1,12 +1,11 @@
 import type { AuthParamsType } from "../../../autogen/types.js";
 export type getDriveFileContentParams = {
     fileId: string;
-    keywords?: string[];
+    mimeType: string;
 };
 export type getDriveFileContentOutput = {
     success: boolean;
     content?: string;
-    fileName?: string;
     error?: string;
 };
 declare const extractContentFromDriveFileId: ({ params, authParams, }: {

package/dist/actions/providers/google-oauth/utils/extractContentFromDriveFileId.js

@@ -9,31 +9,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { axiosClient } from "../../../util/axiosClient.js";
 import mammoth from "mammoth";
-import PDFParser from "pdf2json";
 import { MISSING_AUTH_TOKEN } from "../../../util/missingAuthConstants.js";
 const extractContentFromDriveFileId = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
     if (!authParams.authToken) {
         return { success: false, error: MISSING_AUTH_TOKEN };
     }
-    const { fileId } = params;
+    const { fileId, mimeType } = params;
+    let content = "";
     try {
-        // First, get file metadata to determine the file type
-        const metadataUrl = `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}?fields=name,mimeType,size`;
-        const metadataRes = yield axiosClient.get(metadataUrl, {
-            headers: {
-                Authorization: `Bearer ${authParams.authToken}`,
-            },
-        });
-        const { name: fileName, mimeType, size } = metadataRes.data;
-        // Check if file is too large (50MB limit for safety)
-        const maxFileSize = 50 * 1024 * 1024;
-        if (size && parseInt(size) > maxFileSize) {
-            return {
-                success: false,
-                error: "File too large (>50MB)",
-            };
-        }
-        let content = "";
         // Handle different file types - read content directly
         if (mimeType === "application/vnd.google-apps.document") {
             // Google Docs - download as plain text
@@ -74,37 +57,10 @@ const extractContentFromDriveFileId = (_a) => __awaiter(void 0, [_a], void 0, fu
             content = exportRes.data;
         }
         else if (mimeType === "application/pdf") {
-            // PDF files - use pdf2json
-            const downloadUrl = `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}?alt=media`;
-            const downloadRes = yield axiosClient.get(downloadUrl, {
-                headers: {
-                    Authorization: `Bearer ${authParams.authToken}`,
-                },
-                responseType: "arraybuffer",
-            });
-            try {
-                const pdfParser = new PDFParser(null); // null context, 1 for text extraction
-                // Create a promise to handle the async PDF parsing
-                const pdfContent = yield new Promise((resolve, reject) => {
-                    pdfParser.on("pdfParser_dataError", errData => {
-                        reject(new Error(`PDF parsing error: ${errData.parserError}`));
-                    });
-                    pdfParser.on("pdfParser_dataReady", pdfData => {
-                        // Extract text from all pages
-                        const textContent = pdfData.Pages.map(page => page.Texts.map(text => text.R.map(run => decodeURIComponent(run.T)).join("")).join("")).join("\n");
-                        resolve(textContent);
-                    });
-                    // Parse the PDF buffer
-                    pdfParser.parseBuffer(Buffer.from(downloadRes.data));
-                });
-                content = pdfContent;
-            }
-            catch (pdfError) {
-                return {
-                    success: false,
-                    error: `Failed to parse PDF: ${pdfError instanceof Error ? pdfError.message : "Unknown PDF error"}`,
-                };
-            }
+            return {
+                success: false,
+                error: "PDF files are not supported for text extraction",
+            };
         }
         else if (mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" ||
             mimeType === "application/msword") {
@@ -160,7 +116,6 @@ const extractContentFromDriveFileId = (_a) => __awaiter(void 0, [_a], void 0, fu
         return {
             success: true,
             content,
-            fileName,
         };
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@credal/actions",
-  "version": "0.2.36",
+  "version": "0.2.37",
   "type": "module",
   "description": "AI Actions by Credal AI",
   "sideEffects": false,