@credal/actions 0.2.49 → 0.2.51

package/dist/utils/google.js

@@ -0,0 +1,170 @@
+// Helper function to parse Google Docs content to plain text
+export function parseGoogleDocFromRawContentToPlainText(snapshotRawContent) {
+    var _a, _b, _c, _d, _e, _f;
+    const docSections = [
+        {
+            heading: undefined,
+            paragraphs: [],
+        },
+    ];
+    if (!((_a = snapshotRawContent.body) === null || _a === void 0 ? void 0 : _a.content))
+        return "";
+    for (const content of snapshotRawContent.body.content) {
+        if (!content)
+            continue;
+        // Handle paragraphs (existing logic)
+        if (content.paragraph) {
+            const paragraph = content.paragraph;
+            if ((_b = paragraph.paragraphStyle) === null || _b === void 0 ? void 0 : _b.headingId) {
+                // New heading
+                docSections.push({
+                    heading: {
+                        id: paragraph.paragraphStyle.headingId,
+                        type: paragraph.paragraphStyle.namedStyleType || "",
+                    },
+                    paragraphs: [],
+                });
+            }
+            if (paragraph === null || paragraph === void 0 ? void 0 : paragraph.elements) {
+                const combinedTextRuns = paragraph.elements
+                    .map(element => { var _a; return (_a = element.textRun) === null || _a === void 0 ? void 0 : _a.content; })
+                    .filter((content) => Boolean(content))
+                    .join("");
+                const bulletNestingLevel = paragraph.bullet === undefined ? undefined : ((_d = (_c = paragraph.bullet) === null || _c === void 0 ? void 0 : _c.nestingLevel) !== null && _d !== void 0 ? _d : 0);
+                const paragraphContent = bulletNestingLevel === undefined
+                    ? combinedTextRuns
+                    : "\t".repeat(bulletNestingLevel) + " • " + combinedTextRuns;
+                docSections[docSections.length - 1].paragraphs.push(paragraphContent);
+            }
+        }
+        // Handle tables
+        if (content.table) {
+            const table = content.table;
+            const tableText = [];
+            if (table.tableRows) {
+                for (const row of table.tableRows) {
+                    if (!row.tableCells)
+                        continue;
+                    const cellTexts = [];
+                    for (const cell of row.tableCells) {
+                        if (!cell.content)
+                            continue;
+                        const cellText = [];
+                        for (const cellContent of cell.content) {
+                            if ((_e = cellContent.paragraph) === null || _e === void 0 ? void 0 : _e.elements) {
+                                const cellParagraphText = cellContent.paragraph.elements
+                                    .map(element => { var _a; return (_a = element.textRun) === null || _a === void 0 ? void 0 : _a.content; })
+                                    .filter((content) => Boolean(content))
+                                    .join("");
+                                if (cellParagraphText.trim()) {
+                                    cellText.push(cellParagraphText.trim());
+                                }
+                            }
+                        }
+                        cellTexts.push(cellText.join(" "));
+                    }
+                    if (cellTexts.some(text => text.trim())) {
+                        tableText.push(cellTexts.join(" | "));
+                    }
+                }
+            }
+            if (tableText.length > 0) {
+                docSections[docSections.length - 1].paragraphs.push(tableText.join("\n"));
+            }
+        }
+        // Handle section breaks (just in case they contain text)
+        if (content.sectionBreak) {
+            // Section breaks typically don't contain text, but we'll check anyway
+            // This is mostly for completeness
+            continue;
+        }
+        // Handle table of contents (extract any text)
+        if (content.tableOfContents) {
+            const toc = content.tableOfContents;
+            if (toc.content) {
+                const tocText = [];
+                for (const tocContent of toc.content) {
+                    if ((_f = tocContent.paragraph) === null || _f === void 0 ? void 0 : _f.elements) {
+                        const tocParagraphText = tocContent.paragraph.elements
+                            .map(element => { var _a; return (_a = element.textRun) === null || _a === void 0 ? void 0 : _a.content; })
+                            .filter((content) => Boolean(content))
+                            .join("");
+                        if (tocParagraphText.trim()) {
+                            tocText.push(tocParagraphText.trim());
+                        }
+                    }
+                }
+                if (tocText.length > 0) {
+                    docSections[docSections.length - 1].paragraphs.push(tocText.join("\n"));
+                }
+            }
+        }
+    }
+    const validDocSections = docSections.filter(section => section.heading || section.paragraphs.length > 0);
+    return validDocSections.map(section => section.paragraphs.join(" ")).join("\n");
+}
+export function parseGoogleSheetsFromRawContentToPlainText(snapshotRawContent) {
+    var _a;
+    if (!snapshotRawContent.sheets)
+        return "";
+    const sheetContents = [];
+    for (const sheet of snapshotRawContent.sheets) {
+        if (!sheet.data || !((_a = sheet.properties) === null || _a === void 0 ? void 0 : _a.title))
+            continue;
+        const sheetTitle = sheet.properties.title;
+        const sheetRows = [`Sheet: ${sheetTitle}`];
+        for (const gridData of sheet.data) {
+            if (!gridData.rowData)
+                continue;
+            for (const rowData of gridData.rowData) {
+                if (!rowData.values)
+                    continue;
+                const cellValues = rowData.values
+                    .map(cell => {
+                    var _a, _b, _c;
+                    if (cell.formattedValue)
+                        return cell.formattedValue;
+                    if ((_a = cell.userEnteredValue) === null || _a === void 0 ? void 0 : _a.stringValue)
+                        return cell.userEnteredValue.stringValue;
+                    if ((_b = cell.userEnteredValue) === null || _b === void 0 ? void 0 : _b.numberValue)
+                        return cell.userEnteredValue.numberValue.toString();
+                    if ((_c = cell.userEnteredValue) === null || _c === void 0 ? void 0 : _c.boolValue)
+                        return cell.userEnteredValue.boolValue.toString();
+                    return "";
+                })
+                    .filter(value => value !== "");
+                if (cellValues.length > 0) {
+                    sheetRows.push(cellValues.join(" | "));
+                }
+            }
+        }
+        if (sheetRows.length > 1) {
+            sheetContents.push(sheetRows.join("\n"));
+        }
+    }
+    return sheetContents.join("\n\n");
+}
+export function parseGoogleSlidesFromRawContentToPlainText(snapshotRawContent) {
+    var _a, _b, _c;
+    if (!snapshotRawContent.slides)
+        return "";
+    const slideContents = [];
+    for (const slide of snapshotRawContent.slides) {
+        if (!slide.pageElements)
+            continue;
+        const slideTexts = [];
+        for (const pageElement of slide.pageElements) {
+            if (!((_b = (_a = pageElement.shape) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.textElements))
+                continue;
+            for (const textElement of pageElement.shape.text.textElements) {
+                if ((_c = textElement.textRun) === null || _c === void 0 ? void 0 : _c.content) {
+                    slideTexts.push(textElement.textRun.content.trim());
+                }
+            }
+        }
+        if (slideTexts.length > 0) {
+            slideContents.push(slideTexts.join(" "));
+        }
+    }
+    return slideContents.join("\n\n");
+}

package/package.json

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

package/dist/actions/providers/jamf/types.d.ts

@@ -1,8 +0,0 @@
-import { z } from "zod";
-export declare const TokenResponseSchema: z.ZodObject<{
-    token: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    token: string;
-}, {
-    token: string;
-}>;

package/dist/actions/providers/jamf/types.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenResponseSchema = void 0;
-const zod_1 = require("zod");
-exports.TokenResponseSchema = zod_1.z.object({
-    token: zod_1.z.string(),
-});