@credal/actions 0.2.53 → 0.2.55

package/dist/actions/autogen/templates.js

@@ -9913,7 +9913,7 @@ export const gitlabSearchGroupDefinition = {
                     properties: {
                         metadata: {
                             type: "object",
-                            required: ["path", "basename", "data", "project_id", "ref", "startline", "filename"],
+                            required: ["path", "basename", "data", "project_id", "ref", "startline", "filename", "web_url"],
                             properties: {
                                 path: {
                                     type: "string",
@@ -9943,6 +9943,10 @@ export const gitlabSearchGroupDefinition = {
                                     type: "string",
                                     description: "The filename of the blob",
                                 },
+                                web_url: {
+                                    type: "string",
+                                    description: "The URL of the blob",
+                                },
                             },
                         },
                         matchedMergeRequests: {

package/dist/actions/autogen/types.d.ts

@@ -6716,11 +6716,13 @@ export declare const gitlabSearchGroupOutputSchema: z.ZodObject<{
             ref: z.ZodString;
             startline: z.ZodNumber;
             filename: z.ZodString;
+            web_url: z.ZodString;
         }, "strip", z.ZodTypeAny, {
             path: string;
             data: string;
             filename: string;
             project_id: number;
+            web_url: string;
             basename: string;
             ref: string;
             startline: number;
@@ -6729,6 +6731,7 @@ export declare const gitlabSearchGroupOutputSchema: z.ZodObject<{
             data: string;
             filename: string;
             project_id: number;
+            web_url: string;
             basename: string;
             ref: string;
             startline: number;
@@ -6755,6 +6758,7 @@ export declare const gitlabSearchGroupOutputSchema: z.ZodObject<{
             data: string;
             filename: string;
             project_id: number;
+            web_url: string;
             basename: string;
             ref: string;
             startline: number;
@@ -6771,6 +6775,7 @@ export declare const gitlabSearchGroupOutputSchema: z.ZodObject<{
             data: string;
             filename: string;
             project_id: number;
+            web_url: string;
             basename: string;
             ref: string;
             startline: number;
@@ -6812,6 +6817,7 @@ export declare const gitlabSearchGroupOutputSchema: z.ZodObject<{
             data: string;
             filename: string;
             project_id: number;
+            web_url: string;
             basename: string;
             ref: string;
             startline: number;
@@ -6853,6 +6859,7 @@ export declare const gitlabSearchGroupOutputSchema: z.ZodObject<{
             data: string;
             filename: string;
             project_id: number;
+            web_url: string;
             basename: string;
             ref: string;
             startline: number;

package/dist/actions/autogen/types.js

@@ -3475,6 +3475,7 @@ export const gitlabSearchGroupOutputSchema = z.object({
             ref: z.string().describe("The ref of the blob"),
             startline: z.number().describe("The start line of the blob"),
             filename: z.string().describe("The filename of the blob"),
+            web_url: z.string().describe("The URL of the blob"),
         }),
         matchedMergeRequests: z
             .array(z.object({

package/dist/actions/providers/gitlab/searchGroup.d.ts

@@ -1,6 +1,6 @@
 import type { gitlabSearchGroupFunction } from "../../autogen/types.js";
 /**
- * Creates a new branch in a GitHub repository
+ * Searches for merge requests and blobs in a GitLab group
  */
 declare const searchGroup: gitlabSearchGroupFunction;
 export default searchGroup;

package/dist/actions/providers/gitlab/searchGroup.js

@@ -9,16 +9,75 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
 const GITLAB_API_URL = "https://gitlab.com";
+// Cache for project paths to avoid repeated API calls
+const projectPathCache = new Map();
 function gitlabFetch(endpoint, authToken) {
     return __awaiter(this, void 0, void 0, function* () {
         const res = yield fetch(endpoint, {
-            headers: { Authorization: `Bearer ${authToken}` },
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+            },
         });
         if (!res.ok)
             throw new Error(`GitLab API error: ${res.status} ${res.statusText}`);
         return res.json();
     });
 }
+function getProjectPath(projectId, authToken, baseUrl) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Check cache first
+        if (projectPathCache.has(projectId)) {
+            return projectPathCache.get(projectId);
+        }
+        try {
+            const project = yield gitlabFetch(`${baseUrl}/projects/${projectId}`, authToken);
+            const path = project.path_with_namespace;
+            projectPathCache.set(projectId, path);
+            return path;
+        }
+        catch (error) {
+            console.warn(`Failed to fetch project path for project ${projectId}:`, error);
+            // Fallback to project ID if we can't get the path
+            return `project-${projectId}`;
+        }
+    });
+}
+function constructBlobUrl(input) {
+    const { baseUrl, projectPath, ref, path, startline } = input;
+    let url = `${baseUrl}/${projectPath}/-/blob/${ref}/${path}`;
+    // Add line number anchor if provided
+    if (startline && startline > 0) {
+        url += `#L${startline}`;
+    }
+    return url;
+}
+function enhanceBlobWithUrl(blob, authToken, baseUrl, gitlabWebBaseUrl) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const projectPath = yield getProjectPath(blob.project_id, authToken, baseUrl);
+            const web_url = constructBlobUrl({
+                baseUrl: gitlabWebBaseUrl,
+                projectPath,
+                ref: blob.ref,
+                path: blob.path,
+                startline: blob.startline,
+            });
+            return Object.assign(Object.assign({}, blob), { web_url });
+        }
+        catch (error) {
+            console.warn(`Failed to construct URL for blob in project ${blob.project_id}:`, error);
+            // Fallback URL construction
+            const fallbackUrl = constructBlobUrl({
+                baseUrl: gitlabWebBaseUrl,
+                projectPath: `project-${blob.project_id}`,
+                ref: blob.ref,
+                path: blob.path,
+                startline: blob.startline,
+            });
+            return Object.assign(Object.assign({}, blob), { web_url: fallbackUrl });
+        }
+    });
+}
 function globalSearch(input) {
     return __awaiter(this, void 0, void 0, function* () {
         const { scope, query, groupId, authToken, baseUrl } = input;
@@ -34,29 +93,44 @@ function getMRDiffs(input) {
     });
 }
 /**
- * Creates a new branch in a GitHub repository
+ * Searches for merge requests and blobs in a GitLab group
  */
 const searchGroup = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
     const { authToken, baseUrl } = authParams;
-    const gitlabBaseUrl = `${baseUrl !== null && baseUrl !== void 0 ? baseUrl : GITLAB_API_URL}/api/v4`;
+    const gitlabBaseUrl = baseUrl !== null && baseUrl !== void 0 ? baseUrl : GITLAB_API_URL;
+    const gitlabBaseApiUrl = `${gitlabBaseUrl}/api/v4`;
     if (!authToken) {
         throw new Error(MISSING_AUTH_TOKEN);
     }
     const { query, groupId } = params;
     const [mrResults, blobResults] = yield Promise.all([
-        globalSearch({ scope: "merge_requests", query, groupId, authToken, baseUrl: gitlabBaseUrl }),
-        globalSearch({ scope: "blobs", query, groupId, authToken, baseUrl: gitlabBaseUrl }),
+        globalSearch({
+            scope: "merge_requests",
+            query,
+            groupId,
+            authToken,
+            baseUrl: gitlabBaseApiUrl,
+        }),
+        globalSearch({
+            scope: "blobs",
+            query,
+            groupId,
+            authToken,
+            baseUrl: gitlabBaseApiUrl,
+        }),
     ]);
     const mergeRequests = yield Promise.all(mrResults.map((metadata) => __awaiter(void 0, void 0, void 0, function* () {
         const diffs = yield getMRDiffs({
             projectId: metadata.project_id,
             mrIid: metadata.iid,
             authToken,
-            baseUrl: gitlabBaseUrl,
+            baseUrl: gitlabBaseApiUrl,
         });
         return { metadata, diffs };
     })));
-    const blobs = blobResults.map(blob => {
+    // Enhance blobs with web URLs
+    const blobsWithUrls = yield Promise.all(blobResults.map(blob => enhanceBlobWithUrl(blob, authToken, gitlabBaseApiUrl, gitlabBaseUrl)));
+    const blobs = blobsWithUrls.map(blob => {
         const matches = mergeRequests
             .filter(mr => mr.metadata.project_id === blob.project_id && mr.diffs.some(diff => diff.new_path === blob.path))
             .map(mr => {

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

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { createAxiosClientWithTimeout } from "../../util/axiosClient.js";
+import { createAxiosClientWithTimeout, isAxiosTimeoutError } from "../../util/axiosClient.js";
 import mammoth from "mammoth";
 import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
 import { extractTextFromPdf } from "../../../utils/pdf.js";
@@ -50,16 +50,21 @@ const getDriveFileContentById = (_a) => __awaiter(void 0, [_a], void 0, function
                 content = parseGoogleDocFromRawContentToPlainText(docsRes.data);
             }
             catch (docsError) {
-                console.log("Error using Google Docs API", docsError);
-                // Fallback to Drive API export if Docs API fails
-                const exportUrl = `${BASE_URL}${encodeURIComponent(fileId)}/export?mimeType=text/plain${sharedDriveParams}`;
-                const exportRes = yield axiosClient.get(exportUrl, {
-                    headers: {
-                        Authorization: `Bearer ${authParams.authToken}`,
-                    },
-                    responseType: "text",
-                });
-                content = exportRes.data;
+                if (isAxiosTimeoutError(docsError)) {
+                    console.log("Request timed out using Google Docs API - dont retry");
+                }
+                else {
+                    console.log("Error using Google Docs API", docsError);
+                    // Fallback to Drive API export if Docs API fails
+                    const exportUrl = `${BASE_URL}${encodeURIComponent(fileId)}/export?mimeType=text/plain${sharedDriveParams}`;
+                    const exportRes = yield axiosClient.get(exportUrl, {
+                        headers: {
+                            Authorization: `Bearer ${authParams.authToken}`,
+                        },
+                        responseType: "text",
+                    });
+                    content = exportRes.data;
+                }
             }
         }
         // Google Sheets - use Google Sheets API instead of Drive export
@@ -74,17 +79,22 @@ const getDriveFileContentById = (_a) => __awaiter(void 0, [_a], void 0, function
                 content = parseGoogleSheetsFromRawContentToPlainText(sheetsRes.data);
             }
             catch (sheetsError) {
-                console.log("Error using Google Sheets API", sheetsError);
-                const exportUrl = `${BASE_URL}${encodeURIComponent(fileId)}/export?mimeType=text/csv${sharedDriveParams}`;
-                const exportRes = yield axiosClient.get(exportUrl, {
-                    headers: { Authorization: `Bearer ${authParams.authToken}` },
-                    responseType: "text",
-                });
-                content = exportRes.data
-                    .split("\n")
-                    .map((line) => line.replace(/,+$/, ""))
-                    .map((line) => line.replace(/,{2,}/g, ","))
-                    .join("\n");
+                if (isAxiosTimeoutError(sheetsError)) {
+                    console.log("Request timed out using Google Sheets API - dont retry");
+                }
+                else {
+                    console.log("Error fetching file", sheetsError);
+                    const exportUrl = `${BASE_URL}${encodeURIComponent(fileId)}/export?mimeType=text/csv${sharedDriveParams}`;
+                    const exportRes = yield axiosClient.get(exportUrl, {
+                        headers: { Authorization: `Bearer ${authParams.authToken}` },
+                        responseType: "text",
+                    });
+                    content = exportRes.data
+                        .split("\n")
+                        .map((line) => line.replace(/,+$/, ""))
+                        .map((line) => line.replace(/,{2,}/g, ","))
+                        .join("\n");
+                }
             }
         }
         // Google Slides - use Google Slides API instead of Drive export
@@ -99,13 +109,18 @@ const getDriveFileContentById = (_a) => __awaiter(void 0, [_a], void 0, function
                 content = parseGoogleSlidesFromRawContentToPlainText(slidesRes.data);
             }
             catch (slidesError) {
-                console.log("Error using Google Slides API", slidesError);
-                const exportUrl = `${BASE_URL}${encodeURIComponent(fileId)}/export?mimeType=text/plain${sharedDriveParams}`;
-                const exportRes = yield axiosClient.get(exportUrl, {
-                    headers: { Authorization: `Bearer ${authParams.authToken}` },
-                    responseType: "text",
-                });
-                content = exportRes.data;
+                if (isAxiosTimeoutError(slidesError)) {
+                    console.log("Request timed out using Google Slides API - dont retry");
+                }
+                else {
+                    console.log("Error using Google Slides API", slidesError);
+                    const exportUrl = `${BASE_URL}${encodeURIComponent(fileId)}/export?mimeType=text/plain${sharedDriveParams}`;
+                    const exportRes = yield axiosClient.get(exportUrl, {
+                        headers: { Authorization: `Bearer ${authParams.authToken}` },
+                        responseType: "text",
+                    });
+                    content = exportRes.data;
+                }
             }
         }
         // PDF files - download and extract text using pdfjs-dist

package/dist/actions/util/axiosClient.d.ts

@@ -4,5 +4,6 @@ export declare class ApiError extends Error {
     data?: any;
     constructor(message: string, status?: number, data?: any);
 }
+export declare function isAxiosTimeoutError(error: unknown): boolean;
 export declare const axiosClient: AxiosInstance;
 export declare function createAxiosClientWithTimeout(timeout: number): AxiosInstance;

package/dist/actions/util/axiosClient.js

@@ -7,6 +7,9 @@ export class ApiError extends Error {
         this.data = data;
     }
 }
+export function isAxiosTimeoutError(error) {
+    return error instanceof ApiError && !error.status && !error.data;
+}
 /** Create a configured axios instance with interceptors */
 function createAxiosClient(timeout) {
     const instance = axios.create({

package/package.json

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