flutterflow-mcp 0.2.3 → 0.3.0

package/build/tools/get-custom-code.js

@@ -0,0 +1,380 @@
+import { z } from "zod";
+import YAML from "yaml";
+import { cacheRead, cacheMeta, listCachedKeys } from "../utils/cache.js";
+import { batchProcess } from "../utils/batch-process.js";
+import { resolveDataType } from "../utils/resolve-data-type.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function formatArg(arg) {
+    return arg.required ? `${arg.name}: ${arg.type} (required)` : `${arg.name}: ${arg.type}?`;
+}
+function formatAction(action) {
+    const lines = [];
+    lines.push(`### ${action.name}`);
+    lines.push(`Key: ${action.key} | File: \`${action.fileKey}\``);
+    if (action.args.length === 0) {
+        lines.push("Args: (none)");
+    }
+    else {
+        lines.push(`Args: ${action.args.map(formatArg).join(", ")}`);
+    }
+    lines.push(`Returns: ${action.returnType ?? "void"}`);
+    lines.push(`Context: ${action.includeContext ? "Yes" : "No"}`);
+    if (action.code !== undefined) {
+        lines.push("");
+        lines.push("```dart");
+        lines.push(action.code);
+        lines.push("```");
+    }
+    return lines.join("\n");
+}
+function formatFunction(fn) {
+    const lines = [];
+    lines.push(`### ${fn.name}`);
+    lines.push(`Key: ${fn.key} | File: \`${fn.fileKey}\``);
+    if (fn.args.length === 0) {
+        lines.push("Args: (none)");
+    }
+    else {
+        lines.push(`Args: ${fn.args.map(formatArg).join(", ")}`);
+    }
+    lines.push(`Returns: ${fn.returnType ?? "void"}`);
+    if (fn.code !== undefined) {
+        lines.push("");
+        lines.push("```dart");
+        lines.push(fn.code);
+        lines.push("```");
+    }
+    return lines.join("\n");
+}
+function formatWidget(widget) {
+    const lines = [];
+    lines.push(`### ${widget.name}`);
+    lines.push(`Key: ${widget.key} | File: \`${widget.fileKey}\``);
+    if (widget.params.length === 0) {
+        lines.push("Params: (none)");
+    }
+    else {
+        lines.push("Params:");
+        for (const p of widget.params) {
+            const suffix = p.required ? " (required)" : "";
+            lines.push(`  - ${p.name}: ${p.type}${suffix}`);
+        }
+    }
+    if (widget.code !== undefined) {
+        lines.push("");
+        lines.push("```dart");
+        lines.push(widget.code);
+        lines.push("```");
+    }
+    return lines.join("\n");
+}
+function formatAgent(agent) {
+    const lines = [];
+    lines.push(`### ${agent.displayName} [${agent.status}]`);
+    lines.push(`Key: ${agent.key} | File: \`${agent.fileKey}\``);
+    lines.push(`Provider: ${agent.provider} (${agent.model})`);
+    lines.push(`Input: ${agent.requestTypes.join(", ")}`);
+    lines.push(`Output: ${agent.responseType}`);
+    if (agent.description) {
+        lines.push(`Description: ${agent.description}`);
+    }
+    return lines.join("\n");
+}
+function formatAppAction(action) {
+    const lines = [];
+    lines.push(`### ${action.name}`);
+    lines.push(`Key: ${action.key} | File: \`${action.fileKey}\``);
+    lines.push(`Root action: ${action.rootActionType}(${action.rootActionName})`);
+    if (action.description) {
+        lines.push(`Description: "${action.description}"`);
+    }
+    return lines.join("\n");
+}
+function formatCustomFile(file) {
+    const lines = [];
+    lines.push(`### ${file.name}`);
+    lines.push(`Key: ${file.key} | File: \`${file.fileKey}\``);
+    lines.push(`Type: ${file.fileType}`);
+    lines.push(`Actions: ${file.initialCount} initial, ${file.finalCount} final`);
+    return lines.join("\n");
+}
+function resolveReturnType(returnParam) {
+    if (!returnParam)
+        return null;
+    const dt = returnParam.dataType;
+    if (!dt)
+        return null;
+    const resolved = resolveDataType(dt);
+    const nonNullable = dt.nonNullable ?? false;
+    return nonNullable ? `${resolved} (required)` : `${resolved}?`;
+}
+function parseArgs(rawArgs) {
+    if (!Array.isArray(rawArgs))
+        return [];
+    return rawArgs.map((arg) => {
+        const id = arg.identifier;
+        const name = id?.name || "unknown";
+        const dt = arg.dataType || {};
+        const type = resolveDataType(dt);
+        const required = dt.nonNullable ?? false;
+        return { name, type, required };
+    });
+}
+// ---------------------------------------------------------------------------
+// Category processors
+// ---------------------------------------------------------------------------
+async function processActions(projectId, nameFilter, includeCode) {
+    const allKeys = await listCachedKeys(projectId, "custom-actions/id-");
+    const topKeys = allKeys.filter((k) => /^custom-actions\/id-[a-z0-9]+$/i.test(k));
+    return batchProcess(topKeys, 10, async (fileKey) => {
+        const content = await cacheRead(projectId, fileKey);
+        if (!content)
+            return null;
+        const doc = YAML.parse(content);
+        const id = doc.identifier;
+        const name = id?.name || "unknown";
+        if (nameFilter && name.toLowerCase() !== nameFilter.toLowerCase())
+            return null;
+        const idKey = id?.key || fileKey.match(/id-([a-z0-9]+)$/i)?.[1] || "unknown";
+        const args = parseArgs(doc.arguments);
+        const returnType = resolveReturnType(doc.returnParameter);
+        const includeContext = doc.includeContext ?? false;
+        let code;
+        if (includeCode) {
+            const codeContent = await cacheRead(projectId, `custom-actions/id-${idKey}/action-code.dart`);
+            if (codeContent)
+                code = codeContent;
+        }
+        return { name, key: idKey, fileKey, args, returnType, includeContext, code };
+    }).then((results) => results.filter((r) => r !== null));
+}
+async function processFunctions(projectId, nameFilter, includeCode) {
+    const allKeys = await listCachedKeys(projectId, "custom-functions/id-");
+    const topKeys = allKeys.filter((k) => /^custom-functions\/id-[a-z0-9]+$/i.test(k));
+    return batchProcess(topKeys, 10, async (fileKey) => {
+        const content = await cacheRead(projectId, fileKey);
+        if (!content)
+            return null;
+        const doc = YAML.parse(content);
+        const id = doc.identifier;
+        const name = id?.name || "unknown";
+        if (nameFilter && name.toLowerCase() !== nameFilter.toLowerCase())
+            return null;
+        const idKey = id?.key || fileKey.match(/id-([a-z0-9]+)$/i)?.[1] || "unknown";
+        const args = parseArgs(doc.arguments);
+        const returnType = resolveReturnType(doc.returnParameter);
+        let code;
+        if (includeCode) {
+            const codeContent = await cacheRead(projectId, `custom-functions/id-${idKey}/function-code.dart`);
+            if (codeContent)
+                code = codeContent;
+        }
+        return { name, key: idKey, fileKey, args, returnType, code };
+    }).then((results) => results.filter((r) => r !== null));
+}
+async function processWidgets(projectId, nameFilter, includeCode) {
+    const allKeys = await listCachedKeys(projectId, "custom-widgets/id-");
+    const topKeys = allKeys.filter((k) => /^custom-widgets\/id-[a-z0-9]+$/i.test(k));
+    return batchProcess(topKeys, 10, async (fileKey) => {
+        const content = await cacheRead(projectId, fileKey);
+        if (!content)
+            return null;
+        const doc = YAML.parse(content);
+        const id = doc.identifier;
+        const name = id?.name || "unknown";
+        if (nameFilter && name.toLowerCase() !== nameFilter.toLowerCase())
+            return null;
+        const idKey = id?.key || fileKey.match(/id-([a-z0-9]+)$/i)?.[1] || "unknown";
+        const rawParams = doc.parameters;
+        const params = parseArgs(rawParams);
+        const description = doc.description || "";
+        let code;
+        if (includeCode) {
+            const codeContent = await cacheRead(projectId, `custom-widgets/id-${idKey}/widget-code.dart`);
+            if (codeContent)
+                code = codeContent;
+        }
+        return { name, key: idKey, fileKey, params, description, code };
+    }).then((results) => results.filter((r) => r !== null));
+}
+async function processAgents(projectId, nameFilter) {
+    const allKeys = await listCachedKeys(projectId, "agent/id-");
+    const topKeys = allKeys.filter((k) => /^agent\/id-[a-z0-9]+$/i.test(k));
+    return batchProcess(topKeys, 10, async (fileKey) => {
+        const content = await cacheRead(projectId, fileKey);
+        if (!content)
+            return null;
+        const doc = YAML.parse(content);
+        const id = doc.identifier;
+        const identifierName = id?.name || "unknown";
+        if (nameFilter && identifierName.toLowerCase() !== nameFilter.toLowerCase())
+            return null;
+        const idKey = id?.key || fileKey.match(/id-([a-z0-9]+)$/i)?.[1] || "unknown";
+        const displayName = doc.name || identifierName;
+        const status = doc.status || "UNKNOWN";
+        const aiModel = doc.aiModel;
+        const provider = aiModel?.provider || "UNKNOWN";
+        const model = aiModel?.model || "unknown";
+        const reqOpts = doc.requestOptions;
+        const requestTypes = reqOpts?.requestTypes || [];
+        const resOpts = doc.responseOptions;
+        const responseType = resOpts?.responseType || "UNKNOWN";
+        const description = doc.description || "";
+        return { name: identifierName, key: idKey, fileKey, displayName, status, provider, model, requestTypes, responseType, description };
+    }).then((results) => results.filter((r) => r !== null));
+}
+async function processAppActions(projectId, nameFilter) {
+    const allKeys = await listCachedKeys(projectId, "app-action-components/id-");
+    const topKeys = allKeys.filter((k) => /^app-action-components\/id-[a-z0-9]+$/i.test(k));
+    return batchProcess(topKeys, 10, async (fileKey) => {
+        const content = await cacheRead(projectId, fileKey);
+        if (!content)
+            return null;
+        const doc = YAML.parse(content);
+        const id = doc.identifier;
+        const name = id?.name || "unknown";
+        if (nameFilter && name.toLowerCase() !== nameFilter.toLowerCase())
+            return null;
+        const idKey = id?.key || fileKey.match(/id-([a-z0-9]+)$/i)?.[1] || "unknown";
+        const description = doc.description || "";
+        // Extract root action type and name
+        let rootActionType = "unknown";
+        let rootActionName = "unknown";
+        const actions = doc.actions;
+        const rootAction = actions?.rootAction;
+        const actionObj = rootAction?.action;
+        if (actionObj) {
+            const actionKeys = Object.keys(actionObj);
+            if (actionKeys.length > 0) {
+                rootActionType = actionKeys[0];
+                const actionBody = actionObj[rootActionType];
+                if (actionBody) {
+                    // Look for a sub-key ending in "Identifier" to get the name
+                    for (const subKey of Object.keys(actionBody)) {
+                        if (subKey.endsWith("Identifier")) {
+                            const identifierObj = actionBody[subKey];
+                            rootActionName = identifierObj?.name || rootActionName;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        return { name, key: idKey, fileKey, rootActionType, rootActionName, description };
+    }).then((results) => results.filter((r) => r !== null));
+}
+async function processCustomFiles(projectId, nameFilter) {
+    const allKeys = await listCachedKeys(projectId, "custom-file/id-");
+    const topKeys = allKeys.filter((k) => /^custom-file\/id-[^/]+$/i.test(k) && k !== "custom-file/id-MAIN");
+    return batchProcess(topKeys, 10, async (fileKey) => {
+        const content = await cacheRead(projectId, fileKey);
+        if (!content)
+            return null;
+        const doc = YAML.parse(content);
+        const keyMatch = fileKey.match(/^custom-file\/id-(.+)$/i);
+        const key = keyMatch?.[1] || "unknown";
+        const name = key;
+        if (nameFilter && name.toLowerCase() !== nameFilter.toLowerCase())
+            return null;
+        const fileType = doc.type || "UNKNOWN";
+        const actions = doc.actions || [];
+        let initialCount = 0;
+        let finalCount = 0;
+        for (const action of actions) {
+            if (action.type === "INITIAL_ACTION")
+                initialCount++;
+            else if (action.type === "FINAL_ACTION")
+                finalCount++;
+        }
+        return { name, key, fileKey, fileType, initialCount, finalCount };
+    }).then((results) => results.filter((r) => r !== null));
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGetCustomCodeTool(server) {
+    server.tool("get_custom_code", "Get custom actions, functions, widgets, AI agents, app action components, and custom files from local cache — signatures, arguments, return types, and optionally Dart source code. No API calls. Run sync_project first if not cached.", {
+        projectId: z.string().describe("The FlutterFlow project ID"),
+        type: z
+            .enum(["actions", "functions", "widgets", "agents", "app-actions", "custom-files", "all"])
+            .optional()
+            .default("all")
+            .describe("Type of custom code to retrieve"),
+        name: z
+            .string()
+            .optional()
+            .describe("Case-insensitive filter on identifier name"),
+        includeCode: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Include Dart source code in output"),
+    }, async ({ projectId, type, name, includeCode }) => {
+        const meta = await cacheMeta(projectId);
+        if (!meta) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No cache found for project "${projectId}". Run sync_project first to download the project YAML files.`,
+                    },
+                ],
+            };
+        }
+        const categories = type === "all"
+            ? ["actions", "functions", "widgets", "agents", "app-actions", "custom-files"]
+            : [type];
+        const sections = [];
+        for (const cat of categories) {
+            if (cat === "actions") {
+                const items = await processActions(projectId, name, includeCode);
+                if (items.length > 0) {
+                    sections.push(`## Custom Actions (${items.length})\n\n${items.map(formatAction).join("\n\n")}`);
+                }
+            }
+            else if (cat === "functions") {
+                const items = await processFunctions(projectId, name, includeCode);
+                if (items.length > 0) {
+                    sections.push(`## Custom Functions (${items.length})\n\n${items.map(formatFunction).join("\n\n")}`);
+                }
+            }
+            else if (cat === "widgets") {
+                const items = await processWidgets(projectId, name, includeCode);
+                if (items.length > 0) {
+                    sections.push(`## Custom Widgets (${items.length})\n\n${items.map(formatWidget).join("\n\n")}`);
+                }
+            }
+            else if (cat === "agents") {
+                const items = await processAgents(projectId, name);
+                if (items.length > 0) {
+                    sections.push(`## AI Agents (${items.length})\n\n${items.map(formatAgent).join("\n\n")}`);
+                }
+            }
+            else if (cat === "app-actions") {
+                const items = await processAppActions(projectId, name);
+                if (items.length > 0) {
+                    sections.push(`## App Action Components (${items.length})\n\n${items.map(formatAppAction).join("\n\n")}`);
+                }
+            }
+            else if (cat === "custom-files") {
+                const items = await processCustomFiles(projectId, name);
+                if (items.length > 0) {
+                    sections.push(`## Custom Files (${items.length})\n\n${items.map(formatCustomFile).join("\n\n")}`);
+                }
+            }
+        }
+        if (sections.length === 0) {
+            return {
+                content: [
+                    { type: "text", text: "No custom code found in cache." },
+                ],
+            };
+        }
+        const output = `# Custom Code\n\n${sections.join("\n\n")}`;
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    });
+}

package/build/tools/get-data-models.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerGetDataModelsTool(server: McpServer): void;

package/build/tools/get-data-models.js

@@ -0,0 +1,266 @@
+import { z } from "zod";
+import YAML from "yaml";
+import { cacheRead, cacheMeta, listCachedKeys } from "../utils/cache.js";
+import { batchProcess } from "../utils/batch-process.js";
+import { resolveDataType } from "../utils/resolve-data-type.js";
+async function readStructs(projectId, nameFilter) {
+    const allKeys = await listCachedKeys(projectId, "data-structs/id-");
+    const topLevel = allKeys.filter((k) => /^data-structs\/id-[a-z0-9]+$/i.test(k));
+    const results = await batchProcess(topLevel, 10, async (key) => {
+        const content = await cacheRead(projectId, key);
+        if (!content)
+            return null;
+        let doc;
+        try {
+            doc = YAML.parse(content);
+        }
+        catch {
+            return null;
+        }
+        const identifier = doc.identifier;
+        const name = identifier?.name || "unknown";
+        if (nameFilter && name.toLowerCase() !== nameFilter.toLowerCase())
+            return null;
+        const rawFields = doc.fields;
+        const fields = [];
+        if (Array.isArray(rawFields)) {
+            for (const f of rawFields) {
+                const fId = f.identifier;
+                const fName = fId?.name || "unknown";
+                const dt = f.dataType || {};
+                fields.push({ name: fName, type: resolveDataType(dt) });
+            }
+        }
+        return { name, fields };
+    });
+    return results.filter((r) => r !== null);
+}
+async function readEnums(projectId, nameFilter) {
+    const allKeys = await listCachedKeys(projectId, "enums/id-");
+    const topLevel = allKeys.filter((k) => /^enums\/id-[a-z0-9]+$/i.test(k));
+    const results = await batchProcess(topLevel, 10, async (key) => {
+        const content = await cacheRead(projectId, key);
+        if (!content)
+            return null;
+        let doc;
+        try {
+            doc = YAML.parse(content);
+        }
+        catch {
+            return null;
+        }
+        const identifier = doc.identifier;
+        const name = identifier?.name || "unknown";
+        if (nameFilter && name.toLowerCase() !== nameFilter.toLowerCase())
+            return null;
+        const elements = doc.elements;
+        const values = [];
+        if (Array.isArray(elements)) {
+            for (const el of elements) {
+                const elId = el.identifier;
+                const elName = elId?.name || "unknown";
+                values.push(elName);
+            }
+        }
+        return { name, values };
+    });
+    return results.filter((r) => r !== null);
+}
+async function readCollections(projectId, nameFilter) {
+    const allKeys = await listCachedKeys(projectId, "collections/id-");
+    const topLevel = allKeys.filter((k) => /^collections\/id-[a-z0-9]+$/i.test(k));
+    const results = await batchProcess(topLevel, 10, async (key) => {
+        const content = await cacheRead(projectId, key);
+        if (!content)
+            return null;
+        let doc;
+        try {
+            doc = YAML.parse(content);
+        }
+        catch {
+            return null;
+        }
+        const identifier = doc.identifier;
+        const name = identifier?.name || "unknown";
+        if (nameFilter && name.toLowerCase() !== nameFilter.toLowerCase())
+            return null;
+        const parentId = doc.parentCollectionIdentifier;
+        const parentName = parentId ? (parentId.name || null) : null;
+        const rawFields = doc.fields;
+        const fields = [];
+        if (rawFields && typeof rawFields === "object") {
+            for (const fieldVal of Object.values(rawFields)) {
+                const fId = fieldVal.identifier;
+                const fName = fId?.name || "unknown";
+                const dt = fieldVal.dataType || {};
+                let typeStr = resolveDataType(dt);
+                if (dt.scalarType === "DocumentReference") {
+                    const sub = dt.subType;
+                    const colId = sub?.collectionIdentifier;
+                    if (colId?.name) {
+                        typeStr = `DocumentReference \u2192 ${colId.name}`;
+                    }
+                }
+                fields.push({ name: fName, type: typeStr });
+            }
+        }
+        return { name, parentName, fields };
+    });
+    return results.filter((r) => r !== null);
+}
+async function readSupabaseTables(projectId, nameFilter) {
+    const content = await cacheRead(projectId, "supabase");
+    if (!content)
+        return [];
+    let doc;
+    try {
+        doc = YAML.parse(content);
+    }
+    catch {
+        return [];
+    }
+    const dbConfig = doc.databaseConfig;
+    const tables = dbConfig?.tables;
+    if (!Array.isArray(tables))
+        return [];
+    const results = [];
+    for (const table of tables) {
+        const identifier = table.identifier;
+        const name = identifier?.name || "unknown";
+        if (nameFilter && name.toLowerCase() !== nameFilter.toLowerCase())
+            continue;
+        const rawFields = table.fields;
+        const fields = [];
+        if (Array.isArray(rawFields)) {
+            for (const f of rawFields) {
+                const fId = f.identifier;
+                const fName = fId?.name || "unknown";
+                const typeObj = f.type;
+                const dt = typeObj?.dataType || {};
+                fields.push({
+                    name: fName,
+                    type: resolveDataType(dt),
+                    postgresType: f.postgresType || null,
+                    isPrimaryKey: f.isPrimaryKey || false,
+                    isRequired: f.isRequired || false,
+                    hasDefault: f.hasDefault || false,
+                    foreignKey: f.foreignKey || null,
+                });
+            }
+        }
+        results.push({ name, fields });
+    }
+    return results;
+}
+function formatOutput(structs, enums, collections, supabaseTables, nameFilter) {
+    const total = structs.length + enums.length + collections.length + supabaseTables.length;
+    if (total === 0) {
+        if (nameFilter)
+            return `No data models matching '${nameFilter}' found.`;
+        return "No data models found in cache.";
+    }
+    const sections = [];
+    sections.push("# Data Models");
+    if (structs.length > 0) {
+        sections.push("");
+        sections.push(`## Data Structs (${structs.length})`);
+        for (const s of structs) {
+            sections.push("");
+            sections.push(`### ${s.name}`);
+            for (const f of s.fields) {
+                sections.push(`- ${f.name}: ${f.type}`);
+            }
+        }
+    }
+    if (enums.length > 0) {
+        sections.push("");
+        sections.push(`## Enums (${enums.length})`);
+        for (const e of enums) {
+            sections.push("");
+            sections.push(`### ${e.name}`);
+            sections.push(`Values: ${e.values.join(", ")}`);
+        }
+    }
+    if (collections.length > 0) {
+        sections.push("");
+        sections.push(`## Collections (${collections.length})`);
+        for (const c of collections) {
+            sections.push("");
+            const suffix = c.parentName ? ` (sub-collection of ${c.parentName})` : "";
+            sections.push(`### ${c.name}${suffix}`);
+            for (const f of c.fields) {
+                sections.push(`- ${f.name}: ${f.type}`);
+            }
+        }
+    }
+    if (supabaseTables.length > 0) {
+        sections.push("");
+        sections.push(`## Supabase Tables (${supabaseTables.length})`);
+        for (const t of supabaseTables) {
+            sections.push("");
+            sections.push(`### ${t.name}`);
+            for (const f of t.fields) {
+                const flags = [];
+                if (f.isPrimaryKey)
+                    flags.push("PK");
+                if (f.isRequired)
+                    flags.push("required");
+                if (f.hasDefault)
+                    flags.push("has default");
+                if (f.foreignKey)
+                    flags.push(`FK \u2192 ${f.foreignKey}`);
+                const pgType = f.postgresType ? ` [${f.postgresType}]` : "";
+                const flagStr = flags.length > 0 ? ` (${flags.join(", ")})` : "";
+                sections.push(`- ${f.name}: ${f.type}${pgType}${flagStr}`);
+            }
+        }
+    }
+    return sections.join("\n");
+}
+export function registerGetDataModelsTool(server) {
+    server.tool("get_data_models", "Get data structs, enums, Firestore collections, and Supabase tables from local cache. No API calls. Run sync_project first if not cached.", {
+        projectId: z.string().describe("The FlutterFlow project ID"),
+        type: z
+            .enum(["structs", "enums", "collections", "supabase", "all"])
+            .optional()
+            .default("all")
+            .describe("Filter by model type: structs, enums, collections, supabase, or all (default)."),
+        name: z
+            .string()
+            .optional()
+            .describe("Case-insensitive filter by identifier name."),
+    }, async ({ projectId, type, name }) => {
+        const meta = await cacheMeta(projectId);
+        if (!meta) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No cache found for project "${projectId}". Run sync_project first to download the project YAML files.`,
+                    },
+                ],
+            };
+        }
+        const modelType = (type || "all");
+        let structs = [];
+        let enums = [];
+        let collections = [];
+        let supabaseTables = [];
+        if (modelType === "all" || modelType === "structs") {
+            structs = await readStructs(projectId, name);
+        }
+        if (modelType === "all" || modelType === "enums") {
+            enums = await readEnums(projectId, name);
+        }
+        if (modelType === "all" || modelType === "collections") {
+            collections = await readCollections(projectId, name);
+        }
+        if (modelType === "all" || modelType === "supabase") {
+            supabaseTables = await readSupabaseTables(projectId, name);
+        }
+        const output = formatOutput(structs, enums, collections, supabaseTables, name);
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    });
+}

package/build/tools/get-editing-guide.d.ts

@@ -0,0 +1,7 @@
+/**
+ * get_editing_guide tool — returns workflow steps, relevant YAML docs,
+ * and universal rules for a given FlutterFlow editing task.
+ * No API calls: reads from bundled docs/ff-yaml/ directory.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerGetEditingGuideTool(server: McpServer): void;