totem-llm 0.1.0

package/server/utils/agents/aibitat/plugins/create-files/xlsx/utils.js

@@ -0,0 +1,333 @@
+/**
+ * Parses CSV string into a 2D array of values.
+ * Handles quoted fields, embedded commas, and newlines within quotes.
+ * @param {string} csvString - The CSV content to parse
+ * @param {string} [delimiter=","] - The field delimiter
+ * @returns {string[][]} 2D array of parsed values
+ */
+function parseCSV(csvString, delimiter = ",") {
+  const rows = [];
+  let currentRow = [];
+  let currentField = "";
+  let inQuotes = false;
+
+  for (let i = 0; i < csvString.length; i++) {
+    const char = csvString[i];
+    const nextChar = csvString[i + 1];
+
+    if (inQuotes) {
+      if (char === '"' && nextChar === '"') {
+        currentField += '"';
+        i++;
+      } else if (char === '"') {
+        inQuotes = false;
+      } else {
+        currentField += char;
+      }
+    } else {
+      if (char === '"') {
+        inQuotes = true;
+      } else if (char === delimiter) {
+        currentRow.push(currentField.trim());
+        currentField = "";
+      } else if (char === "\r" && nextChar === "\n") {
+        currentRow.push(currentField.trim());
+        rows.push(currentRow);
+        currentRow = [];
+        currentField = "";
+        i++;
+      } else if (char === "\n" || char === "\r") {
+        currentRow.push(currentField.trim());
+        rows.push(currentRow);
+        currentRow = [];
+        currentField = "";
+      } else {
+        currentField += char;
+      }
+    }
+  }
+
+  if (currentField || currentRow.length > 0) {
+    currentRow.push(currentField.trim());
+    rows.push(currentRow);
+  }
+
+  return rows.filter((row) => row.some((cell) => cell !== ""));
+}
+
+/**
+ * Validates CSV data structure.
+ * @param {string[][]} data - Parsed CSV data
+ * @returns {{valid: boolean, error?: string, warnings?: string[]}}
+ */
+function validateCSVData(data) {
+  const warnings = [];
+
+  if (!data || data.length === 0) {
+    return { valid: false, error: "CSV data is empty" };
+  }
+
+  if (data.length === 1 && data[0].length === 1 && !data[0][0]) {
+    return { valid: false, error: "CSV data contains no meaningful content" };
+  }
+
+  const columnCounts = data.map((row) => row.length);
+  const maxColumns = Math.max(...columnCounts);
+  const minColumns = Math.min(...columnCounts);
+
+  if (maxColumns !== minColumns) {
+    warnings.push(
+      `Inconsistent column count: rows have between ${minColumns} and ${maxColumns} columns. Missing cells will be empty.`
+    );
+  }
+
+  if (maxColumns > 16384) {
+    return {
+      valid: false,
+      error: `CSV has ${maxColumns} columns, exceeding Excel's limit of 16,384 columns`,
+    };
+  }
+
+  if (data.length > 1048576) {
+    return {
+      valid: false,
+      error: `CSV has ${data.length} rows, exceeding Excel's limit of 1,048,576 rows`,
+    };
+  }
+
+  return { valid: true, warnings: warnings.length > 0 ? warnings : undefined };
+}
+
+/**
+ * Attempts to detect the delimiter used in a CSV string.
+ * @param {string} csvString - The CSV content
+ * @returns {string} Detected delimiter (comma, semicolon, tab, or pipe)
+ */
+function detectDelimiter(csvString) {
+  const firstLine = csvString.split(/\r?\n/)[0] || "";
+  const delimiters = [",", ";", "\t", "|"];
+  let bestDelimiter = ",";
+  let maxCount = 0;
+
+  for (const delimiter of delimiters) {
+    const count = (firstLine.match(new RegExp(`\\${delimiter}`, "g")) || [])
+      .length;
+    if (count > maxCount) {
+      maxCount = count;
+      bestDelimiter = delimiter;
+    }
+  }
+
+  return bestDelimiter;
+}
+
+/**
+ * Attempts to convert a string value to an appropriate type (number, date, boolean, or string).
+ * @param {string} value - The string value to convert
+ * @returns {string|number|Date|boolean} The converted value
+ */
+function inferCellType(value) {
+  if (value === "" || value === null || value === undefined) {
+    return "";
+  }
+
+  const trimmed = value.trim();
+  const lowerTrimmed = trimmed.toLowerCase();
+
+  if (lowerTrimmed === "true") return true;
+  if (lowerTrimmed === "false") return false;
+
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+    const num = parseFloat(trimmed);
+    if (!isNaN(num) && isFinite(num)) {
+      return num;
+    }
+  }
+
+  if (/^-?\d{1,3}(,\d{3})*(\.\d+)?$/.test(trimmed)) {
+    const num = parseFloat(trimmed.replace(/,/g, ""));
+    if (!isNaN(num) && isFinite(num)) {
+      return num;
+    }
+  }
+
+  const currencyMatch = trimmed.match(/^[$€£¥₹]?\s*(-?\d+(?:[,.\d]*\d)?)\s*$/);
+  if (currencyMatch) {
+    const num = parseFloat(currencyMatch[1].replace(/,/g, ""));
+    if (!isNaN(num) && isFinite(num)) {
+      return num;
+    }
+  }
+
+  if (/^\d+(\.\d+)?%$/.test(trimmed)) {
+    const num = parseFloat(trimmed) / 100;
+    if (!isNaN(num) && isFinite(num)) {
+      return num;
+    }
+  }
+
+  const datePatterns = [
+    /^\d{4}-\d{2}-\d{2}$/,
+    /^\d{2}\/\d{2}\/\d{4}$/,
+    /^\d{2}-\d{2}-\d{4}$/,
+    /^\d{4}\/\d{2}\/\d{2}$/,
+  ];
+
+  for (const pattern of datePatterns) {
+    if (pattern.test(trimmed)) {
+      const date = new Date(trimmed);
+      if (!isNaN(date.getTime())) {
+        return date;
+      }
+    }
+  }
+
+  return value;
+}
+
+/**
+ * Applies AnythingLLM branding to an Excel workbook.
+ * Adds a subtle "Created with AnythingLLM" text row below the data on each sheet.
+ * @param {import('exceljs').Workbook} workbook - The ExcelJS workbook instance
+ */
+function applyBranding(workbook) {
+  for (const worksheet of workbook.worksheets) {
+    const lastRow = worksheet.rowCount || 1;
+    const lastCol = worksheet.columnCount || 1;
+
+    const brandingRowNum = lastRow + 2;
+
+    if (lastCol > 1) {
+      worksheet.mergeCells(brandingRowNum, 1, brandingRowNum, lastCol);
+    }
+
+    const brandingCell = worksheet.getCell(brandingRowNum, 1);
+    brandingCell.value = "Created with AnythingLLM";
+    brandingCell.font = {
+      italic: true,
+      size: 9,
+      color: { argb: "FF999999" },
+    };
+    brandingCell.alignment = {
+      horizontal: "right",
+      vertical: "middle",
+    };
+  }
+}
+
+/**
+ * Auto-fits column widths based on content.
+ * @param {import('exceljs').Worksheet} worksheet - The worksheet to auto-fit
+ * @param {number} [minWidth=8] - Minimum column width
+ * @param {number} [maxWidth=50] - Maximum column width
+ */
+function autoFitColumns(worksheet, minWidth = 8, maxWidth = 50) {
+  worksheet.columns.forEach((column, colIndex) => {
+    let maxLength = minWidth;
+
+    worksheet.eachRow({ includeEmpty: false }, (row) => {
+      const cell = row.getCell(colIndex + 1);
+      const cellValue = cell.value;
+      let cellLength = minWidth;
+
+      if (cellValue !== null && cellValue !== undefined) {
+        if (typeof cellValue === "string") {
+          cellLength = cellValue.length;
+        } else if (cellValue instanceof Date) {
+          cellLength = 12;
+        } else if (typeof cellValue === "number") {
+          cellLength = cellValue.toString().length;
+        } else if (typeof cellValue === "object" && cellValue.richText) {
+          cellLength = cellValue.richText.reduce(
+            (acc, rt) => acc + (rt.text?.length || 0),
+            0
+          );
+        } else {
+          cellLength = String(cellValue).length;
+        }
+      }
+
+      maxLength = Math.max(maxLength, cellLength);
+    });
+
+    column.width = Math.min(maxLength + 2, maxWidth);
+  });
+}
+
+/**
+ * Applies header styling to the first row of a worksheet.
+ * @param {import('exceljs').Worksheet} worksheet - The worksheet to style
+ * @param {Object} [options] - Styling options
+ * @param {boolean} [options.bold=true] - Make headers bold
+ * @param {string} [options.fill] - Background color (ARGB format, e.g., 'FF4472C4')
+ * @param {string} [options.fontColor] - Font color (ARGB format, e.g., 'FFFFFFFF')
+ */
+function applyHeaderStyle(
+  worksheet,
+  { bold = true, fill = "FF4472C4", fontColor = "FFFFFFFF" } = {}
+) {
+  const headerRow = worksheet.getRow(1);
+  if (!headerRow || headerRow.cellCount === 0) return;
+
+  headerRow.eachCell((cell) => {
+    cell.font = {
+      bold,
+      color: { argb: fontColor },
+    };
+    cell.fill = {
+      type: "pattern",
+      pattern: "solid",
+      fgColor: { argb: fill },
+    };
+    cell.alignment = {
+      vertical: "middle",
+      horizontal: "center",
+    };
+  });
+
+  headerRow.height = 20;
+}
+
+/**
+ * Applies alternating row colors (zebra striping) to a worksheet.
+ * @param {import('exceljs').Worksheet} worksheet - The worksheet to style
+ * @param {string} [evenColor='FFF2F2F2'] - Color for even rows (ARGB format)
+ * @param {number} [startRow=2] - Row to start alternating from (skips header)
+ */
+function applyZebraStriping(worksheet, evenColor = "FFF2F2F2", startRow = 2) {
+  worksheet.eachRow({ includeEmpty: false }, (row, rowNumber) => {
+    if (rowNumber >= startRow && rowNumber % 2 === 0) {
+      row.eachCell((cell) => {
+        if (!cell.fill || cell.fill.type !== "pattern") {
+          cell.fill = {
+            type: "pattern",
+            pattern: "solid",
+            fgColor: { argb: evenColor },
+          };
+        }
+      });
+    }
+  });
+}
+
+/**
+ * Freezes the header row and optionally first columns.
+ * @param {import('exceljs').Worksheet} worksheet - The worksheet to modify
+ * @param {number} [rows=1] - Number of rows to freeze
+ * @param {number} [columns=0] - Number of columns to freeze
+ */
+function freezePanes(worksheet, rows = 1, columns = 0) {
+  worksheet.views = [{ state: "frozen", xSplit: columns, ySplit: rows }];
+}
+
+module.exports = {
+  parseCSV,
+  validateCSVData,
+  detectDelimiter,
+  inferCellType,
+  applyBranding,
+  autoFitColumns,
+  applyHeaderStyle,
+  applyZebraStriping,
+  freezePanes,
+};

package/server/utils/agents/aibitat/plugins/file-history.js

@@ -0,0 +1,37 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Plugin to save chat history to a json file
+ */
+const fileHistory = {
+  name: "file-history-plugin",
+  startupConfig: {
+    params: {},
+  },
+  plugin: function ({
+    filename = `history/chat-history-${new Date().toISOString()}.json`,
+  } = {}) {
+    return {
+      name: this.name,
+      setup(aibitat) {
+        const folderPath = path.dirname(filename);
+        // get path from filename
+        if (folderPath) {
+          fs.mkdirSync(folderPath, { recursive: true });
+        }
+
+        aibitat.onMessage(() => {
+          const content = JSON.stringify(aibitat.chats, null, 2);
+          fs.writeFile(filename, content, (err) => {
+            if (err) {
+              console.error(err);
+            }
+          });
+        });
+      },
+    };
+  },
+};
+
+module.exports = { fileHistory };

package/server/utils/agents/aibitat/plugins/filesystem/copy-file.js

@@ -0,0 +1,127 @@
+const fs = require("fs/promises");
+const path = require("path");
+const filesystem = require("./lib.js");
+
+async function copyRecursive(source, destination) {
+  const lstat = await fs.lstat(source);
+
+  if (lstat.isSymbolicLink()) {
+    throw new Error(
+      `Cannot copy symbolic link: ${source}. Symlinks are not allowed during copy operations.`
+    );
+  }
+
+  if (lstat.isDirectory()) {
+    await fs.mkdir(destination, { recursive: true });
+    const entries = await fs.readdir(source);
+    for (const entry of entries) {
+      await copyRecursive(
+        path.join(source, entry),
+        path.join(destination, entry)
+      );
+    }
+  } else {
+    await fs.copyFile(source, destination);
+  }
+}
+
+module.exports.FilesystemCopyFile = {
+  name: "filesystem-copy-file",
+  plugin: function () {
+    return {
+      name: "filesystem-copy-file",
+      setup(aibitat) {
+        aibitat.function({
+          super: aibitat,
+          name: this.name,
+          description:
+            "Copy files and directories. Creates a duplicate of the source at the destination path. " +
+            "For directories, performs a recursive copy of all contents. If the destination exists, " +
+            "the operation will fail. Both source and destination must be within allowed directories.",
+          examples: [
+            {
+              prompt: "Make a backup copy of config.json",
+              call: JSON.stringify({
+                source: "config.json",
+                destination: "config.backup.json",
+              }),
+            },
+            {
+              prompt: "Copy the templates folder to a new location",
+              call: JSON.stringify({
+                source: "templates",
+                destination: "templates-backup",
+              }),
+            },
+          ],
+          parameters: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            type: "object",
+            properties: {
+              source: {
+                type: "string",
+                description: "The path of the file or directory to copy.",
+              },
+              destination: {
+                type: "string",
+                description:
+                  "The destination path where the copy should be created.",
+              },
+            },
+            required: ["source", "destination"],
+            additionalProperties: false,
+          },
+          handler: async function ({ source = "", destination = "" }) {
+            try {
+              this.super.handlerProps.log(
+                `Using the filesystem-copy-file tool.`
+              );
+
+              const validSourcePath = await filesystem.validatePath(source);
+              const validDestPath = await filesystem.validatePath(destination);
+
+              this.super.introspect(
+                `${this.caller}: Copying ${source} to ${destination}`
+              );
+
+              if (this.super.requestToolApproval) {
+                const approval = await this.super.requestToolApproval({
+                  skillName: this.name,
+                  payload: { source, destination },
+                  description: "Copy a file or directory to a new location",
+                });
+                if (!approval.approved) {
+                  this.super.introspect(
+                    `${this.caller}: User rejected the ${this.name} request.`
+                  );
+                  return approval.message;
+                }
+              }
+
+              const destExists = await fs
+                .access(validDestPath)
+                .then(() => true)
+                .catch(() => false);
+
+              if (destExists) {
+                return `Error: Destination "${destination}" already exists. Please choose a different destination.`;
+              }
+
+              await copyRecursive(validSourcePath, validDestPath);
+              this.super.introspect(
+                `Successfully copied ${source} to ${destination}`
+              );
+              return `Successfully copied ${source} to ${destination}`;
+            } catch (e) {
+              this.super.handlerProps.log(
+                `filesystem-copy-file error: ${e.message}`
+              );
+              this.super.introspect(`Error: ${e.message}`);
+              return `Error copying file: ${e.message}`;
+            }
+          },
+        });
+      },
+    };
+  },
+};

package/server/utils/agents/aibitat/plugins/filesystem/create-directory.js

@@ -0,0 +1,84 @@
+const fs = require("fs/promises");
+const filesystem = require("./lib.js");
+
+module.exports.FilesystemCreateDirectory = {
+  name: "filesystem-create-directory",
+  plugin: function () {
+    return {
+      name: "filesystem-create-directory",
+      setup(aibitat) {
+        aibitat.function({
+          super: aibitat,
+          name: this.name,
+          description:
+            "Create a new directory or ensure a directory exists. Can create multiple " +
+            "nested directories in one operation. If the directory already exists, " +
+            "this operation will succeed silently. Perfect for setting up directory " +
+            "structures for projects or ensuring required paths exist. Only works within allowed directories.",
+          examples: [
+            {
+              prompt: "Create a new folder called 'reports'",
+              call: JSON.stringify({ path: "reports" }),
+            },
+            {
+              prompt: "Create nested directories for the new module",
+              call: JSON.stringify({ path: "src/modules/auth/utils" }),
+            },
+          ],
+          parameters: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            type: "object",
+            properties: {
+              path: {
+                type: "string",
+                description:
+                  "The path of the directory to create. Can include nested paths.",
+              },
+            },
+            required: ["path"],
+            additionalProperties: false,
+          },
+          handler: async function ({ path: dirPath = "" }) {
+            try {
+              this.super.handlerProps.log(
+                `Using the filesystem-create-directory tool.`
+              );
+
+              const validPath = await filesystem.validatePath(dirPath);
+              this.super.introspect(
+                `${this.caller}: Creating directory ${dirPath}`
+              );
+
+              if (this.super.requestToolApproval) {
+                const approval = await this.super.requestToolApproval({
+                  skillName: this.name,
+                  payload: { path: dirPath },
+                  description: "Create a new directory",
+                });
+
+                if (!approval.approved) {
+                  this.super.introspect(
+                    `${this.caller}: User rejected the ${this.name} request.`
+                  );
+                  return approval.message;
+                }
+              }
+
+              await fs.mkdir(validPath, { recursive: true });
+              this.super.introspect(
+                `Successfully created directory ${dirPath}`
+              );
+              return `Successfully created directory ${dirPath}`;
+            } catch (e) {
+              this.super.handlerProps.log(
+                `filesystem-create-directory error: ${e.message}`
+              );
+              this.super.introspect(`Error: ${e.message}`);
+              return `Error creating directory: ${e.message}`;
+            }
+          },
+        });
+      },
+    };
+  },
+};