flutterflow-mcp 0.1.0

package/build/utils/page-summary/action-summarizer.js

@@ -0,0 +1,291 @@
+/**
+ * Summarize trigger_actions chains for a widget node.
+ *
+ * Walks the rootAction→followUpAction→conditionActions chain in the trigger
+ * file, reads individual action files, and classifies each action by type.
+ */
+import YAML from "yaml";
+import { cacheRead, listCachedKeys } from "../cache.js";
+/**
+ * Collect all action keys referenced in a trigger chain.
+ * Flattens followUpAction chains, conditionActions, and parallelActions.
+ */
+function collectActionKeys(node) {
+    const keys = [];
+    // Direct action reference
+    const action = node.action;
+    if (action?.key) {
+        keys.push(action.key);
+    }
+    // Conditional branches
+    const cond = node.conditionActions;
+    if (cond) {
+        // True branches
+        const trueActions = cond.trueActions;
+        if (Array.isArray(trueActions)) {
+            for (const branch of trueActions) {
+                const trueAction = branch.trueAction;
+                if (trueAction) {
+                    keys.push(...collectActionKeys(trueAction));
+                }
+            }
+        }
+        // False branch
+        const falseAction = cond.falseAction;
+        if (falseAction && !("terminate" in falseAction)) {
+            keys.push(...collectActionKeys(falseAction));
+        }
+        // followUpAction after conditionActions
+        const condFollowUp = cond.followUpAction;
+        if (condFollowUp) {
+            keys.push(...collectActionKeys(condFollowUp));
+        }
+    }
+    // Parallel actions
+    const parallel = node.parallelActions;
+    if (parallel) {
+        const actions = parallel.actions;
+        if (Array.isArray(actions)) {
+            for (const branch of actions) {
+                keys.push(...collectActionKeys(branch));
+            }
+        }
+    }
+    // Follow-up chain
+    const followUp = node.followUpAction;
+    if (followUp) {
+        keys.push(...collectActionKeys(followUp));
+    }
+    return keys;
+}
+/** Known top-level keys that identify an action type. */
+const ACTION_TYPE_KEYS = [
+    "navigate", "customAction", "database", "localStateUpdate", "waitAction",
+    "alertDialog", "bottomSheet", "revenueCat", "auth", "rebuild", "scrollTo",
+    "copyToClipboard", "share", "hapticFeedback",
+];
+/**
+ * Recursively search an object tree for the first recognizable action.
+ * Used to unwrap disableAction nodes where the real action is buried
+ * inside conditionalActions or other nesting.
+ */
+function findDeepAction(obj, depth = 0) {
+    if (!obj || typeof obj !== "object" || depth > 8)
+        return null;
+    const o = obj;
+    // Check if this object itself is a classifiable action
+    for (const key of ACTION_TYPE_KEYS) {
+        if (key in o)
+            return classifyAction(o);
+    }
+    // Recurse into object values
+    for (const val of Object.values(o)) {
+        if (val && typeof val === "object") {
+            const found = findDeepAction(val, depth + 1);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+/**
+ * Classify an action YAML into a human-readable summary.
+ */
+function classifyAction(doc) {
+    // Disabled action — unwrap and recursively find the inner action
+    if ("disableAction" in doc) {
+        const da = doc.disableAction;
+        const actionNode = da.actionNode;
+        if (actionNode) {
+            const inner = findDeepAction(actionNode);
+            if (inner) {
+                return {
+                    type: `[DISABLED] ${inner.type}`,
+                    detail: inner.detail,
+                };
+            }
+        }
+        return { type: "[DISABLED]", detail: "" };
+    }
+    // Navigate
+    if ("navigate" in doc) {
+        const nav = doc.navigate;
+        if (nav.isNavigateBack) {
+            return { type: "navigate", detail: "back" };
+        }
+        return { type: "navigate", detail: "to page" };
+    }
+    // Custom action
+    if ("customAction" in doc) {
+        const ca = doc.customAction;
+        const id = ca.customActionIdentifier;
+        const name = doc.outputVariableName;
+        return {
+            type: "customAction",
+            detail: name || id?.key || "unknown",
+        };
+    }
+    // Database
+    if ("database" in doc) {
+        const db = doc.database;
+        const pg = db.postgresAction;
+        if (pg) {
+            const table = pg.tableIdentifier;
+            const tableName = table?.name || "table";
+            const op = "insert" in pg ? "insert" : "update" in pg ? "update" : "query" in pg ? "query" : "delete" in pg ? "delete" : "op";
+            return { type: "database", detail: `${op} ${tableName}` };
+        }
+        const firestore = db.firestoreAction;
+        if (firestore) {
+            return { type: "database", detail: "firestore" };
+        }
+        return { type: "database", detail: "" };
+    }
+    // Local state update
+    if ("localStateUpdate" in doc) {
+        const lsu = doc.localStateUpdate;
+        const stateType = lsu.stateVariableType || "";
+        const updates = lsu.updates;
+        if (stateType === "APP_STATE") {
+            return { type: "updateAppState", detail: "" };
+        }
+        if (updates && updates.length > 0) {
+            const first = updates[0];
+            if ("increment" in first)
+                return { type: "updateState", detail: "increment" };
+            if ("dataStructUpdate" in first)
+                return { type: "updateState", detail: "struct" };
+        }
+        return { type: "updateState", detail: "" };
+    }
+    // Wait
+    if ("waitAction" in doc) {
+        const wa = doc.waitAction;
+        const dur = wa.durationMillisValue;
+        const ms = dur?.inputValue;
+        return { type: "wait", detail: ms ? `${ms}ms` : "" };
+    }
+    // Alert dialog
+    if ("alertDialog" in doc) {
+        return { type: "alertDialog", detail: "" };
+    }
+    // Bottom sheet
+    if ("bottomSheet" in doc) {
+        return { type: "bottomSheet", detail: "" };
+    }
+    // RevenueCat
+    if ("revenueCat" in doc) {
+        const rc = doc.revenueCat;
+        if ("purchase" in rc)
+            return { type: "revenueCat", detail: "purchase" };
+        if ("restore" in rc)
+            return { type: "revenueCat", detail: "restore" };
+        if ("paywall" in rc) {
+            const pw = rc.paywall;
+            const eid = pw.entitlementId;
+            const iv = eid?.inputValue;
+            const name = iv?.serializedValue || "";
+            return { type: "revenueCat", detail: name ? `paywall (${name})` : "paywall" };
+        }
+        return { type: "revenueCat", detail: "" };
+    }
+    // Authentication
+    if ("auth" in doc) {
+        return { type: "auth", detail: "" };
+    }
+    // Rebuild (update widget / rebuild)
+    if ("rebuild" in doc) {
+        return { type: "rebuild", detail: "" };
+    }
+    // Scroll to
+    if ("scrollTo" in doc) {
+        return { type: "scrollTo", detail: "" };
+    }
+    // Copy to clipboard
+    if ("copyToClipboard" in doc) {
+        return { type: "copyToClipboard", detail: "" };
+    }
+    // Share
+    if ("share" in doc) {
+        return { type: "share", detail: "" };
+    }
+    // Haptic feedback
+    if ("hapticFeedback" in doc) {
+        return { type: "haptic", detail: "" };
+    }
+    // Terminate sentinel — skip
+    if ("terminate" in doc) {
+        return { type: "terminate", detail: "" };
+    }
+    // Fallback: use first key
+    const actionKeys = Object.keys(doc).filter((k) => k !== "key" && k !== "outputVariableName");
+    return { type: actionKeys[0] || "unknown", detail: "" };
+}
+/**
+ * Read all trigger_actions for a node and return summaries.
+ *
+ * @param projectId - FF project ID
+ * @param nodeFileKeyPrefix - Cache prefix for the node's trigger actions,
+ *   e.g. "page/id-Scaffold_xxx/page-widget-tree-outline/node/id-Button_yyy"
+ */
+export async function summarizeTriggers(projectId, nodeFileKeyPrefix) {
+    const triggerPrefix = `${nodeFileKeyPrefix}/trigger_actions/`;
+    const allKeys = await listCachedKeys(projectId, triggerPrefix);
+    // Find trigger definition files (e.g. trigger_actions/id-ON_TAP)
+    // These don't have /action/ in the path
+    const triggerDefKeys = allKeys.filter((k) => !k.includes("/action/") && k.startsWith(triggerPrefix + "id-"));
+    // Deduplicate: a key like "trigger_actions/id-ON_TAP" may also appear as a
+    // directory prefix "trigger_actions/id-ON_TAP/action/..." — we only want the
+    // file, which is the shortest matching key
+    const triggerFiles = triggerDefKeys.filter((k) => {
+        const afterPrefix = k.slice(triggerPrefix.length);
+        // Should be just "id-ON_TAP" with no further slashes
+        return !afterPrefix.includes("/");
+    });
+    const results = [];
+    for (const triggerFileKey of triggerFiles) {
+        const content = await cacheRead(projectId, triggerFileKey);
+        if (!content)
+            continue;
+        let doc;
+        try {
+            doc = YAML.parse(content);
+        }
+        catch {
+            continue;
+        }
+        // Extract trigger type
+        const trigger = doc.trigger;
+        const triggerType = trigger?.triggerType || "UNKNOWN";
+        // Collect action keys from chain
+        const rootAction = doc.rootAction;
+        if (!rootAction)
+            continue;
+        const actionKeys = collectActionKeys(rootAction);
+        // Deduplicate while preserving order
+        const uniqueKeys = [...new Set(actionKeys)];
+        // Read each action file
+        const actionPrefix = `${triggerFileKey}/action/`;
+        const actions = [];
+        for (const actionKey of uniqueKeys) {
+            const actionFileKey = `${actionPrefix}id-${actionKey}`;
+            const actionContent = await cacheRead(projectId, actionFileKey);
+            if (!actionContent)
+                continue;
+            try {
+                const actionDoc = YAML.parse(actionContent);
+                const summary = classifyAction(actionDoc);
+                if (summary.type !== "terminate") {
+                    actions.push(summary);
+                }
+            }
+            catch {
+                actions.push({ type: "unknown", detail: actionKey });
+            }
+        }
+        if (actions.length > 0) {
+            results.push({ trigger: triggerType, actions });
+        }
+    }
+    return results;
+}

package/build/utils/page-summary/formatter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Render a PageMeta + SummaryNode tree as a readable text summary
+ * with box-drawing characters and inline trigger summaries.
+ */
+import { ComponentMeta, PageMeta, SummaryNode } from "./types.js";
+/**
+ * Format a complete page summary as text.
+ */
+export declare function formatPageSummary(meta: PageMeta, tree: SummaryNode): string;
+/**
+ * Format a complete component summary as text.
+ */
+export declare function formatComponentSummary(meta: ComponentMeta, tree: SummaryNode): string;

package/build/utils/page-summary/formatter.js

@@ -0,0 +1,121 @@
+/** Format a single action into a compact string. */
+function fmtAction(a) {
+    if (a.detail)
+        return `${a.type}: ${a.detail}`;
+    return a.type;
+}
+/** Format a trigger into a compact inline string like "ON_TAP: [navigate to page, customAction: foo]". */
+function fmtTrigger(t) {
+    const acts = t.actions.map(fmtAction).join(", ");
+    return `${t.trigger} → [${acts}]`;
+}
+/** Format the slot prefix for display. */
+function fmtSlot(slot) {
+    if (slot === "children" || slot === "root")
+        return "";
+    return `[${slot}] `;
+}
+/** Build a display label for a node. */
+function nodeLabel(node) {
+    const parts = [];
+    parts.push(fmtSlot(node.slot));
+    parts.push(node.type);
+    if (node.name) {
+        parts.push(` (${node.name})`);
+    }
+    if (node.detail) {
+        parts.push(` ${node.detail}`);
+    }
+    return parts.join("");
+}
+/**
+ * Render the widget tree recursively with box-drawing characters.
+ */
+function renderTree(node, prefix, isLast, isRoot, lines) {
+    // Build connector
+    const connector = isRoot ? "" : isLast ? "└── " : "├── ";
+    const label = nodeLabel(node);
+    // Triggers inline
+    const triggerStr = node.triggers.length > 0
+        ? " → " + node.triggers.map(fmtTrigger).join("; ")
+        : "";
+    lines.push(`${prefix}${connector}${label}${triggerStr}`);
+    // Child prefix
+    const childPrefix = isRoot ? prefix : prefix + (isLast ? "    " : "│   ");
+    for (let i = 0; i < node.children.length; i++) {
+        renderTree(node.children[i], childPrefix, i === node.children.length - 1, false, lines);
+    }
+}
+/**
+ * Format a complete page summary as text.
+ */
+export function formatPageSummary(meta, tree) {
+    const lines = [];
+    // Header
+    lines.push(`${meta.pageName} (${meta.scaffoldId}) — folder: ${meta.folder}`);
+    // Params
+    if (meta.params.length > 0) {
+        const paramStrs = meta.params.map((p) => {
+            const def = p.defaultValue ? `, default: ${p.defaultValue}` : "";
+            return `${p.name} (${p.dataType}${def})`;
+        });
+        lines.push(`Params: ${paramStrs.join(", ")}`);
+    }
+    // State fields
+    if (meta.stateFields.length > 0) {
+        const stateStrs = meta.stateFields.map((s) => {
+            const def = s.defaultValue ? `, default: ${s.defaultValue}` : "";
+            return `${s.name} (${s.dataType}${def})`;
+        });
+        lines.push(`State: ${stateStrs.join(", ")}`);
+    }
+    // Scaffold-level triggers
+    if (tree.triggers.length > 0) {
+        lines.push("");
+        for (const t of tree.triggers) {
+            lines.push(fmtTrigger(t));
+        }
+    }
+    // Widget tree
+    lines.push("");
+    lines.push("Widget Tree:");
+    // Render children directly (skip the Scaffold root itself)
+    for (let i = 0; i < tree.children.length; i++) {
+        renderTree(tree.children[i], "", i === tree.children.length - 1, false, lines);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a complete component summary as text.
+ */
+export function formatComponentSummary(meta, tree) {
+    const lines = [];
+    // Header
+    lines.push(`${meta.componentName} (${meta.containerId})`);
+    if (meta.description) {
+        lines.push(`Description: ${meta.description}`);
+    }
+    // Params
+    if (meta.params.length > 0) {
+        const paramStrs = meta.params.map((p) => {
+            const def = p.defaultValue ? `, default: ${p.defaultValue}` : "";
+            return `${p.name} (${p.dataType}${def})`;
+        });
+        lines.push(`Params: ${paramStrs.join(", ")}`);
+    }
+    // Root-level triggers
+    if (tree.triggers.length > 0) {
+        lines.push("");
+        for (const t of tree.triggers) {
+            lines.push(fmtTrigger(t));
+        }
+    }
+    // Widget tree
+    lines.push("");
+    lines.push("Widget Tree:");
+    // Render children directly (skip the Container root itself)
+    for (let i = 0; i < tree.children.length; i++) {
+        renderTree(tree.children[i], "", i === tree.children.length - 1, false, lines);
+    }
+    return lines.join("\n");
+}

package/build/utils/page-summary/node-extractor.d.ts

@@ -0,0 +1,17 @@
+export interface NodeInfo {
+    type: string;
+    name: string;
+    detail: string;
+}
+/**
+ * Infer widget type from the key prefix (e.g. "Text_abc123" → "Text").
+ */
+export declare function inferTypeFromKey(key: string): string;
+/**
+ * Read a node's cached file and extract type, name, and detail.
+ *
+ * @param projectId - The FF project ID
+ * @param pagePrefix - Cache key prefix for the page, e.g. "page/id-Scaffold_xxx/page-widget-tree-outline"
+ * @param nodeKey - The node key, e.g. "Button_uaqbabys"
+ */
+export declare function extractNodeInfo(projectId: string, pagePrefix: string, nodeKey: string): Promise<NodeInfo>;

package/build/utils/page-summary/node-extractor.js

@@ -0,0 +1,207 @@
+/**
+ * Read a node's cached YAML and extract human-readable details
+ * based on widget type (text value, button label, image path, etc.).
+ */
+import YAML from "yaml";
+import { cacheRead } from "../cache.js";
+/**
+ * Resolve the inputValue from a FF value object.
+ * Returns the literal string, or "[dynamic]" for variable references.
+ */
+function resolveValue(obj) {
+    if (obj == null)
+        return "";
+    if (typeof obj === "string" || typeof obj === "number")
+        return String(obj);
+    if (typeof obj !== "object")
+        return "";
+    const o = obj;
+    // Direct inputValue
+    if ("inputValue" in o) {
+        const iv = o.inputValue;
+        if (typeof iv === "string" || typeof iv === "number")
+            return String(iv);
+        if (iv && typeof iv === "object") {
+            const ivo = iv;
+            // serializedValue pattern
+            if ("serializedValue" in ivo)
+                return String(ivo.serializedValue);
+            // themeColor pattern
+            if ("themeColor" in ivo)
+                return `[theme:${ivo.themeColor}]`;
+            // color value pattern
+            if ("value" in ivo)
+                return String(ivo.value);
+        }
+        return "";
+    }
+    // Variable reference
+    if ("variable" in o)
+        return "[dynamic]";
+    return "";
+}
+/** Extract text value from a text widget's props. */
+function extractText(props) {
+    const text = props.text;
+    if (!text)
+        return "";
+    const textValue = text.textValue;
+    if (!textValue)
+        return "";
+    const val = resolveValue(textValue);
+    return val ? `"${val}"` : "";
+}
+/** Extract button label from a button widget's props. */
+function extractButton(props) {
+    const button = props.button;
+    if (!button)
+        return "";
+    const text = button.text;
+    if (!text)
+        return "";
+    const textValue = text.textValue;
+    if (!textValue)
+        return "";
+    const val = resolveValue(textValue);
+    return val ? `"${val}"` : "";
+}
+/** Extract image info from an image widget's props. */
+function extractImage(props) {
+    const image = props.image;
+    if (!image)
+        return "";
+    const parts = [];
+    // Path
+    const pathValue = image.pathValue;
+    if (pathValue) {
+        const path = resolveValue(pathValue);
+        if (path && path !== "[dynamic]") {
+            // Extract just the filename from the full asset path
+            const filename = path.split("/").pop() || path;
+            parts.push(filename);
+        }
+        else if (path === "[dynamic]") {
+            parts.push("[dynamic]");
+        }
+    }
+    // Dimensions
+    const dims = image.dimensions;
+    if (dims) {
+        const w = dims.width;
+        const h = dims.height;
+        const wVal = w?.pixelsValue ? resolveValue(w.pixelsValue) : "";
+        const hVal = h?.pixelsValue ? resolveValue(h.pixelsValue) : "";
+        if (wVal && hVal && wVal !== "Infinity" && hVal !== "Infinity") {
+            parts.push(`[${wVal}x${hVal}]`);
+        }
+    }
+    return parts.join(" ");
+}
+/** Extract icon info. */
+function extractIcon(props) {
+    const icon = props.icon;
+    if (!icon)
+        return "";
+    const iconData = icon.iconDataValue;
+    if (!iconData)
+        return "";
+    const iv = iconData.inputValue;
+    if (!iv)
+        return "";
+    return iv.name || "";
+}
+/** Extract text field hint. */
+function extractTextField(props) {
+    const tf = props.textField;
+    if (!tf)
+        return "";
+    const decoration = tf.inputDecoration;
+    if (!decoration)
+        return "";
+    const hintText = decoration.hintText;
+    if (!hintText)
+        return "";
+    const textValue = hintText.textValue;
+    if (!textValue)
+        return "";
+    const val = resolveValue(textValue);
+    return val ? `hint: "${val}"` : "";
+}
+/** Extract checkbox/toggle/switch label. */
+function extractCheckbox(props) {
+    const cb = (props.checkbox || props.toggle || props.switchWidget);
+    if (!cb)
+        return "";
+    const label = cb.labelValue;
+    if (!label)
+        return "";
+    return resolveValue(label);
+}
+/** Type-specific detail extraction. */
+function extractDetail(type, props) {
+    switch (type) {
+        case "Text":
+        case "RichText":
+        case "AutoSizeText":
+            return extractText(props);
+        case "Button":
+        case "IconButton":
+        case "FFButtonWidget":
+            return extractButton(props);
+        case "Image":
+        case "CachedNetworkImage":
+            return extractImage(props);
+        case "Icon":
+            return extractIcon(props);
+        case "TextField":
+        case "TextFormField":
+            return extractTextField(props);
+        case "Checkbox":
+        case "CheckboxListTile":
+        case "Switch":
+        case "ToggleIcon":
+            return extractCheckbox(props);
+        default:
+            return "";
+    }
+}
+/**
+ * Infer widget type from the key prefix (e.g. "Text_abc123" → "Text").
+ */
+export function inferTypeFromKey(key) {
+    const match = key.match(/^([A-Z][a-zA-Z]*)_/);
+    return match ? match[1] : "Unknown";
+}
+/**
+ * Read a node's cached file and extract type, name, and detail.
+ *
+ * @param projectId - The FF project ID
+ * @param pagePrefix - Cache key prefix for the page, e.g. "page/id-Scaffold_xxx/page-widget-tree-outline"
+ * @param nodeKey - The node key, e.g. "Button_uaqbabys"
+ */
+export async function extractNodeInfo(projectId, pagePrefix, nodeKey) {
+    const fileKey = `${pagePrefix}/node/id-${nodeKey}`;
+    const content = await cacheRead(projectId, fileKey);
+    if (!content) {
+        return {
+            type: inferTypeFromKey(nodeKey),
+            name: "",
+            detail: "",
+        };
+    }
+    try {
+        const doc = YAML.parse(content);
+        const type = doc.type || inferTypeFromKey(nodeKey);
+        const name = doc.name || "";
+        const props = doc.props || {};
+        const detail = extractDetail(type, props);
+        return { type, name, detail };
+    }
+    catch {
+        return {
+            type: inferTypeFromKey(nodeKey),
+            name: "",
+            detail: "",
+        };
+    }
+}

package/build/utils/page-summary/tree-walker.d.ts

@@ -0,0 +1,6 @@
+import { OutlineNode } from "./types.js";
+/**
+ * Parse the page-widget-tree-outline YAML string into an OutlineNode tree.
+ * Returns the root node (typically the Scaffold).
+ */
+export declare function parseTreeOutline(yamlContent: string): OutlineNode;