@realtimex/folio 0.1.2

package/dist/api/src/utils/actions/LogCsvAction.js

@@ -0,0 +1,42 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pickString, pickColumns, interpolate, getNestedVariable } from "./utils.js";
+import { Actuator } from "../Actuator.js";
+export class LogCsvAction {
+    async execute(context) {
+        const { action, variables, data, userId, ingestionId, supabase } = context;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const csvPathTemplate = pickString(action, "path");
+        if (!csvPathTemplate) {
+            return {
+                success: false,
+                logs: [],
+                trace: [{ timestamp: new Date().toISOString(), step: "Log CSV failed: missing path" }],
+                error: "Log CSV action requires a 'path' config"
+            };
+        }
+        const csvPath = interpolate(csvPathTemplate, variables, data);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const cols = pickColumns(action, Object.keys(data));
+        const row = cols.map((c) => getNestedVariable(c, variables, data) ?? "").join(",") + "\n";
+        const header = cols.join(",") + "\n";
+        if (!fs.existsSync(csvPath)) {
+            fs.mkdirSync(path.dirname(csvPath), { recursive: true });
+            fs.writeFileSync(csvPath, header + row, "utf-8");
+        }
+        else {
+            fs.appendFileSync(csvPath, row, "utf-8");
+        }
+        const trace = [{
+                timestamp: new Date().toISOString(),
+                step: "Executed log_csv action",
+                details: { csvPath, cols }
+            }];
+        Actuator.logEvent(ingestionId, userId, "action", "Action Execution", { action: "log_csv", csvPath, cols }, supabase);
+        return {
+            success: true,
+            logs: [`Logged CSV → ${csvPath}`],
+            trace
+        };
+    }
+}

package/dist/api/src/utils/actions/NotifyAction.js

@@ -0,0 +1,32 @@
+import { pickString, interpolate } from "./utils.js";
+import { Actuator } from "../Actuator.js";
+import { createLogger } from "../logger.js";
+const logger = createLogger("NotifyAction");
+export class NotifyAction {
+    async execute(context) {
+        const { action, variables, data, userId, ingestionId, supabase } = context;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const messageTemplate = pickString(action, "message");
+        if (!messageTemplate) {
+            return {
+                success: false,
+                logs: [],
+                trace: [{ timestamp: new Date().toISOString(), step: "Notify failed: missing message" }],
+                error: "Notify action requires a 'message' config"
+            };
+        }
+        const msg = interpolate(messageTemplate, variables, data);
+        logger.info(`[NOTIFY] ${msg}`);
+        const trace = [{
+                timestamp: new Date().toISOString(),
+                step: "Executed notify action",
+                details: { message: msg }
+            }];
+        Actuator.logEvent(ingestionId, userId, "action", "Action Execution", { action: "notify", message: msg }, supabase);
+        return {
+            success: true,
+            logs: [`Notified: ${msg}`],
+            trace
+        };
+    }
+}

package/dist/api/src/utils/actions/RenameAction.js

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pickString, interpolate } from "./utils.js";
+import { Actuator } from "../Actuator.js";
+import { getServiceRoleSupabase } from "../../services/supabase.js";
+export class RenameAction {
+    async execute(context) {
+        const { action, file, variables, data, userId, ingestionId, supabase } = context;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const pattern = pickString(action, "pattern");
+        if (!pattern) {
+            return {
+                success: false,
+                logs: [],
+                trace: [{ timestamp: new Date().toISOString(), step: "Rename failed: missing pattern" }],
+                error: "Rename action requires a 'pattern' config"
+            };
+        }
+        const ext = path.extname(file.path);
+        const dir = path.dirname(file.path);
+        let newName = interpolate(pattern, variables, data);
+        if (!newName.endsWith(ext))
+            newName += ext;
+        const newPath = path.join(dir, newName);
+        await new Promise((resolve, reject) => {
+            fs.rename(file.path, newPath, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+        const trace = [{
+                timestamp: new Date().toISOString(),
+                step: `Renamed file to ${newName}`,
+                details: { original: file.name, new: newName }
+            }];
+        Actuator.logEvent(ingestionId, userId, "action", "Action Execution", { action: "rename", original: file.name, new: newName }, supabase);
+        // Update DB so re-runs don't break
+        const db = supabase ?? getServiceRoleSupabase();
+        if (db) {
+            await db.from("ingestions").update({ storage_path: newPath, filename: newName }).eq("id", ingestionId);
+        }
+        return {
+            success: true,
+            newFileState: { path: newPath, name: newName },
+            logs: [`Renamed to '${newName}'`],
+            trace
+        };
+    }
+}

package/dist/api/src/utils/actions/WebhookAction.js

@@ -0,0 +1,51 @@
+import { pickString, interpolate } from "./utils.js";
+import { Actuator } from "../Actuator.js";
+export class WebhookAction {
+    async execute(context) {
+        const { action, variables, data, userId, ingestionId, supabase } = context;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const webhookUrlTemplate = pickString(action, "url");
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const webhookPayloadTemplate = pickString(action, "payload");
+        if (!webhookUrlTemplate || !webhookPayloadTemplate) {
+            return {
+                success: false,
+                logs: [],
+                trace: [{ timestamp: new Date().toISOString(), step: "Webhook failed: missing url or payload" }],
+                error: "Webhook action requires 'url' and 'payload' configs"
+            };
+        }
+        const url = interpolate(webhookUrlTemplate, variables, data);
+        const payloadStr = interpolate(webhookPayloadTemplate, variables, data);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let payload;
+        try {
+            payload = JSON.parse(payloadStr);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) {
+            return {
+                success: false,
+                logs: [],
+                trace: [{ timestamp: new Date().toISOString(), step: "Webhook failed: invalid JSON payload" }],
+                error: "Webhook payload must be valid JSON"
+            };
+        }
+        await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+        });
+        const trace = [{
+                timestamp: new Date().toISOString(),
+                step: `Webhook payload sent to ${url}`,
+                details: { url, payload }
+            }];
+        Actuator.logEvent(ingestionId, userId, "action", "Action Execution", { action: "webhook", url }, supabase);
+        return {
+            success: true,
+            logs: [`Logged via webhook`],
+            trace
+        };
+    }
+}

package/dist/api/src/utils/actions/utils.js

@@ -0,0 +1,237 @@
+import { createLogger } from "../logger.js";
+const logger = createLogger("ActionUtils");
+// ─── Variable Interpolation ────────────────────────────────────────────────
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function maybeParseJson(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    if (!((trimmed.startsWith("{") && trimmed.endsWith("}")) || (trimmed.startsWith("[") && trimmed.endsWith("]")))) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function tokenizePath(path) {
+    const tokens = [];
+    let i = 0;
+    while (i < path.length) {
+        const ch = path[i];
+        if (ch === ".") {
+            i += 1;
+            continue;
+        }
+        if (ch === "[") {
+            const end = path.indexOf("]", i + 1);
+            if (end < 0)
+                break;
+            const raw = path.slice(i + 1, end).trim();
+            if (/^\d+$/.test(raw)) {
+                tokens.push(Number(raw));
+            }
+            else {
+                const unquoted = raw.replace(/^["']|["']$/g, "");
+                if (unquoted)
+                    tokens.push(unquoted);
+            }
+            i = end + 1;
+            continue;
+        }
+        let j = i;
+        while (j < path.length && path[j] !== "." && path[j] !== "[") {
+            j += 1;
+        }
+        const token = path.slice(i, j).trim();
+        if (token)
+            tokens.push(token);
+        i = j;
+    }
+    return tokens;
+}
+function toTemplateString(value) {
+    if (value == null)
+        return undefined;
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function getNestedVariable(keyPath, vars, data) {
+    const key = keyPath.trim();
+    if (!key)
+        return undefined;
+    if (vars[key] !== undefined) {
+        return vars[key];
+    }
+    const root = {
+        ...(data ?? {}),
+        ...vars,
+    };
+    const tokens = tokenizePath(key);
+    if (tokens.length === 0)
+        return undefined;
+    let current = root;
+    for (let i = 0; i < tokens.length; i += 1) {
+        if (typeof current === "string") {
+            const parsed = maybeParseJson(current);
+            if (parsed !== undefined) {
+                current = parsed;
+            }
+        }
+        const token = tokens[i];
+        if (Array.isArray(current)) {
+            if (typeof token !== "number")
+                return undefined;
+            current = current[token];
+            continue;
+        }
+        if (!isRecord(current)) {
+            return undefined;
+        }
+        if (typeof token === "number") {
+            current = current[String(token)];
+            continue;
+        }
+        const lookupToken = i === 0 && token === "enrichment" && current["_enrichment"] !== undefined
+            ? "_enrichment"
+            : token;
+        current = current[lookupToken];
+    }
+    return toTemplateString(current);
+}
+export function interpolate(template, vars, data) {
+    return template.replace(/\{([^{}]+)\}/g, (match, rawKey) => {
+        const resolved = getNestedVariable(rawKey, vars, data);
+        return resolved ?? match;
+    });
+}
+/**
+ * Derive computed variables from extracted data using transformer definitions.
+ */
+export function deriveVariables(data, fields) {
+    const vars = {};
+    // Populate raw extracted values as strings
+    for (const [k, v] of Object.entries(data)) {
+        const serialized = toTemplateString(v);
+        if (serialized !== undefined)
+            vars[k] = serialized;
+    }
+    // Run transformers
+    for (const field of fields) {
+        if (!field.transformers)
+            continue;
+        const rawValue = vars[field.key];
+        if (!rawValue)
+            continue;
+        for (const t of field.transformers) {
+            try {
+                if (t.name === "get_year") {
+                    vars[t.as] = new Date(rawValue).getFullYear().toString();
+                }
+                else if (t.name === "get_month_name") {
+                    vars[t.as] = new Date(rawValue).toLocaleString("en-US", { month: "long" });
+                }
+                else if (t.name === "get_month") {
+                    vars[t.as] = String(new Date(rawValue).getMonth() + 1).padStart(2, "0");
+                }
+            }
+            catch {
+                logger.warn(`Transformer '${t.name}' failed for key '${field.key}'`);
+            }
+        }
+    }
+    return vars;
+}
+export function pickString(action, key) {
+    const value = action.config?.[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+        return value;
+    }
+    const legacyValue = action[key];
+    if (typeof legacyValue === "string" && legacyValue.trim().length > 0) {
+        return legacyValue;
+    }
+    return undefined;
+}
+// ─── Filename Helpers ──────────────────────────────────────────────────────
+/**
+ * Build a filename stem from extracted metadata when suggested_filename is unavailable.
+ * Format: YYYY-MM-DD_Issuer_DocType  (any missing parts are simply omitted)
+ */
+export function deriveNameFromVariables(variables) {
+    const parts = [];
+    if (variables.date) {
+        const d = new Date(variables.date);
+        if (!isNaN(d.getTime())) {
+            const yyyy = d.getFullYear();
+            const MM = String(d.getMonth() + 1).padStart(2, "0");
+            const dd = String(d.getDate()).padStart(2, "0");
+            parts.push(`${yyyy}-${MM}-${dd}`);
+        }
+    }
+    if (variables.issuer) {
+        parts.push(variables.issuer.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-|-$/g, ""));
+    }
+    if (variables.document_type) {
+        parts.push(variables.document_type.replace(/\s+/g, "-").replace(/[^a-zA-Z0-9-]+/g, ""));
+    }
+    if (variables.amount || variables.total_amount) {
+        const raw = (variables.amount ?? variables.total_amount).replace(/[^0-9.$€£]/g, "");
+        if (raw)
+            parts.push(raw);
+    }
+    return parts.length > 0 ? parts.join("_") : null;
+}
+/**
+ * Resolve a final filename given the action's `filename` config field.
+ *
+ * Modes:
+ *   undefined / "" / "original" → keep original stem + ext
+ *   "auto"                       → AI suggested_filename → derived → originalStem, then + ext
+ *   any other string             → treat as a {variable} interpolation pattern
+ */
+export function resolveFilename(filenameConfig, variables, originalStem, ext, data) {
+    if (!filenameConfig || filenameConfig === "original") {
+        return originalStem + ext;
+    }
+    if (filenameConfig === "auto") {
+        const smart = deriveNameFromVariables(variables) ||
+            variables.suggested_filename?.trim() ||
+            originalStem;
+        return smart.endsWith(ext) ? smart : smart + ext;
+    }
+    // Custom interpolation pattern
+    const interpolated = interpolate(filenameConfig, variables, data);
+    return interpolated.endsWith(ext) ? interpolated : interpolated + ext;
+}
+export function pickColumns(action, fallback) {
+    const value = action.config?.columns;
+    if (Array.isArray(value)) {
+        return value.map((item) => String(item).trim()).filter(Boolean);
+    }
+    if (typeof value === "string") {
+        return value.split(",").map((item) => item.trim()).filter(Boolean);
+    }
+    const legacyColumns = action.columns;
+    if (Array.isArray(legacyColumns)) {
+        return legacyColumns.map((item) => String(item).trim()).filter(Boolean);
+    }
+    if (typeof legacyColumns === "string") {
+        return legacyColumns.split(",").map((item) => item.trim()).filter(Boolean);
+    }
+    return fallback;
+}

package/dist/api/src/utils/llmResponse.js

@@ -0,0 +1,63 @@
+export function normalizeLlmContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (typeof content === "number" || typeof content === "boolean")
+        return String(content);
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (part && typeof part === "object") {
+                const obj = part;
+                if (typeof obj.text === "string")
+                    return obj.text;
+                if (typeof obj.content === "string")
+                    return obj.content;
+            }
+            return normalizeLlmContent(part);
+        })
+            .filter(Boolean)
+            .join("\n");
+    }
+    if (content && typeof content === "object") {
+        const obj = content;
+        if (typeof obj.text === "string")
+            return obj.text;
+        if (typeof obj.content === "string")
+            return obj.content;
+        if ("content" in obj)
+            return normalizeLlmContent(obj.content);
+        try {
+            return JSON.stringify(obj);
+        }
+        catch {
+            return String(obj);
+        }
+    }
+    return "";
+}
+/**
+ * Robustly extracts the text payload from various SDK adapter response shapes.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function extractLlmResponse(result) {
+    if (!result)
+        return "";
+    const candidates = [
+        result.response?.content,
+        result.message?.content,
+        result.content,
+        result.text,
+        result.choices?.[0]?.message?.content,
+        result.result,
+        result.output,
+    ];
+    for (const candidate of candidates) {
+        const normalized = normalizeLlmContent(candidate);
+        if (normalized)
+            return normalized;
+    }
+    return "";
+}
+export function previewLlmText(raw, maxChars = 240) {
+    return raw.replace(/\s+/g, " ").trim().slice(0, maxChars);
+}

package/dist/api/src/utils/logger.js

@@ -0,0 +1,51 @@
+class LoggerCore {
+    static persistence = null;
+    static setPersistence(supabase, userId) {
+        this.persistence = { supabase, userId };
+    }
+    static clearPersistence() {
+        this.persistence = null;
+    }
+    static async persist(level, scope, message, data) {
+        if (!this.persistence) {
+            return;
+        }
+        try {
+            await this.persistence.supabase.from("system_logs").insert({
+                user_id: this.persistence.userId,
+                level,
+                scope,
+                message,
+                metadata: data || {}
+            });
+        }
+        catch {
+            // persistence is best-effort and should never crash request flow
+        }
+    }
+}
+export const Logger = LoggerCore;
+export function createLogger(scope) {
+    function write(level, message, data) {
+        const line = `[${scope}] ${message}`;
+        if (level === "error") {
+            console.error(line, data || "");
+        }
+        else if (level === "warn") {
+            console.warn(line, data || "");
+        }
+        else if (level === "info") {
+            console.info(line, data || "");
+        }
+        else {
+            console.debug(line, data || "");
+        }
+        void Logger.persist(level, scope, message, data);
+    }
+    return {
+        debug: (message, data) => write("debug", message, data),
+        info: (message, data) => write("info", message, data),
+        warn: (message, data) => write("warn", message, data),
+        error: (message, data) => write("error", message, data)
+    };
+}