flutterflow-mcp 0.2.5 → 0.3.0

package/build/tools/get-general-settings.js

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import YAML from "yaml";
+import { cacheRead, cacheMeta } from "../utils/cache.js";
+async function resolvePageName(projectId, scaffoldId) {
+    const content = await cacheRead(projectId, `page/id-${scaffoldId}`);
+    if (!content)
+        return scaffoldId;
+    const nameMatch = content.match(/^name:\s*(.+)$/m);
+    return nameMatch ? nameMatch[1].trim() : scaffoldId;
+}
+export function registerGetGeneralSettingsTool(server) {
+    server.tool("get_general_settings", "Get General settings — App Details (name, package, initial page, routing), App Assets (icon, splash, error image), Nav Bar & App Bar. Mirrors the FlutterFlow 'General' settings section. Cache-based, no API calls. Run sync_project first.", {
+        projectId: z.string().describe("The FlutterFlow project ID"),
+    }, async ({ projectId }) => {
+        const meta = await cacheMeta(projectId);
+        if (!meta) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No cache found for project "${projectId}". Run sync_project first.`,
+                    },
+                ],
+            };
+        }
+        const [appDetailsRaw, appAssetsRaw, navBarRaw] = await Promise.all([
+            cacheRead(projectId, "app-details"),
+            cacheRead(projectId, "app-assets"),
+            cacheRead(projectId, "nav-bar"),
+        ]);
+        const sections = ["# General Settings"];
+        // --- App Details ---
+        if (appDetailsRaw) {
+            const appDetails = YAML.parse(appDetailsRaw);
+            const appName = appDetails.name || "Unknown";
+            // Package name: take first env's packageName
+            let packageName = "not set";
+            const allAppNames = appDetails.allAppNames;
+            const appNames = allAppNames?.appNames;
+            if (appNames) {
+                const firstEnvKey = Object.keys(appNames)[0];
+                if (firstEnvKey) {
+                    packageName = appNames[firstEnvKey].packageName || "not set";
+                }
+            }
+            // Initial page
+            const initialPageKey = appDetails.initialPageKeyRef?.key;
+            let initialPageLine = "not set";
+            if (initialPageKey) {
+                const name = await resolvePageName(projectId, initialPageKey);
+                initialPageLine = `${name} (${initialPageKey})`;
+            }
+            // Routing
+            const routing = appDetails.routingSettings;
+            const routingEnabled = routing?.enableRouting === true;
+            const subroutes = routing?.pagesAreSubroutesOfRoot === true;
+            sections.push(`\n## App Details`, `Name: ${appName}`, `Package name: ${packageName}`, `Initial page: ${initialPageLine}`, `Routing: ${routingEnabled ? "enabled" : "disabled"}, pages are subroutes: ${subroutes ? "yes" : "no"}`);
+        }
+        else {
+            sections.push(`\n## App Details`, `(not configured)`);
+        }
+        // --- App Assets ---
+        if (appAssetsRaw) {
+            const appAssets = YAML.parse(appAssetsRaw);
+            const appIconPath = appAssets.appIconPath || "not set";
+            const splashImage = appAssets.splashImage;
+            const errorImagePath = appAssets.errorImagePath || "not set";
+            sections.push(`\n## App Assets`);
+            sections.push(`App icon: ${appIconPath}`);
+            if (splashImage) {
+                const splashPath = splashImage.path || "not set";
+                const splashFit = splashImage.fit || "not set";
+                const splashDuration = splashImage.minSplashScreenDuration;
+                sections.push(`Splash image: ${splashPath} (fit: ${splashFit})`);
+                if (splashDuration)
+                    sections.push(`Splash duration: ${splashDuration}ms`);
+            }
+            else {
+                sections.push(`Splash image: not set`);
+            }
+            sections.push(`Error image: ${errorImagePath}`);
+        }
+        else {
+            sections.push(`\n## App Assets`, `(not configured)`);
+        }
+        // --- Nav Bar & App Bar ---
+        if (navBarRaw) {
+            const navBar = YAML.parse(navBarRaw);
+            const visible = navBar.show === true;
+            if (visible) {
+                const navType = navBar.navBarType || "UNKNOWN";
+                const labels = navBar.labels === true;
+                const pageRefs = navBar.pageKeyRefOrder;
+                sections.push(`\n## Nav Bar & App Bar`, `Visible: Yes`, `Type: ${navType}`, `Labels: ${labels ? "Yes" : "No"}`);
+                if (pageRefs && pageRefs.length > 0) {
+                    const tabs = [];
+                    for (let i = 0; i < pageRefs.length; i++) {
+                        const scaffoldId = pageRefs[i].key;
+                        const name = await resolvePageName(projectId, scaffoldId);
+                        tabs.push(`  ${i + 1}. ${name} (${scaffoldId})`);
+                    }
+                    sections.push(`Tabs:`, ...tabs);
+                }
+            }
+            else {
+                sections.push(`\n## Nav Bar & App Bar`, `Visible: No`);
+            }
+        }
+        else {
+            sections.push(`\n## Nav Bar & App Bar`, `(not configured)`);
+        }
+        return {
+            content: [{ type: "text", text: sections.join("\n") }],
+        };
+    });
+}

package/build/tools/get-in-app-purchases.d.ts

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

package/build/tools/get-in-app-purchases.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import YAML from "yaml";
+import { cacheRead, cacheMeta } from "../utils/cache.js";
+const PROVIDERS = [
+    { key: "stripe", label: "Stripe" },
+    { key: "braintree", label: "Braintree" },
+    { key: "revenue-cat", label: "RevenueCat" },
+    { key: "razorpay", label: "Razorpay" },
+];
+export function registerGetInAppPurchasesTool(server) {
+    server.tool("get_in_app_purchases", "Get In-App Purchases & Subscriptions settings — Stripe, Braintree, RevenueCat, Razorpay. Mirrors the FlutterFlow 'In App Purchases & Subscriptions' section. Cache-based, no API calls. Run sync_project first.", {
+        projectId: z.string().describe("The FlutterFlow project ID"),
+    }, async ({ projectId }) => {
+        const meta = await cacheMeta(projectId);
+        if (!meta) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No cache found for project "${projectId}". Run sync_project first.`,
+                    },
+                ],
+            };
+        }
+        const sections = ["# In-App Purchases & Subscriptions"];
+        for (const provider of PROVIDERS) {
+            const raw = await cacheRead(projectId, provider.key);
+            sections.push(`\n## ${provider.label}`);
+            if (!raw) {
+                sections.push("(not configured)");
+                continue;
+            }
+            const doc = YAML.parse(raw);
+            const enabled = doc.enabled === true;
+            sections.push(`Enabled: ${enabled ? "Yes" : "No"}`);
+            // Show any additional top-level scalar fields (skip 'enabled' itself and complex objects)
+            for (const [key, value] of Object.entries(doc)) {
+                if (key === "enabled")
+                    continue;
+                if (value === null || value === undefined)
+                    continue;
+                if (typeof value === "object")
+                    continue;
+                sections.push(`${key}: ${String(value)}`);
+            }
+        }
+        return {
+            content: [{ type: "text", text: sections.join("\n") }],
+        };
+    });
+}

package/build/tools/get-integrations.d.ts

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

package/build/tools/get-integrations.js

@@ -0,0 +1,137 @@
+import { z } from "zod";
+import YAML from "yaml";
+import { cacheRead, cacheMeta } from "../utils/cache.js";
+/**
+ * Fields that should never be output — API keys, secrets, tokens, etc.
+ * Only IDs and non-sensitive configuration are shown.
+ */
+const SENSITIVE_KEYS = new Set([
+    "searchApiKey",
+    "supabaseAnonKey",
+    "supabaseServiceRoleKey",
+    "apiKey",
+    "secretKey",
+    "secret",
+    "token",
+    "accessToken",
+    "refreshToken",
+    "privateKey",
+]);
+// ---------------------------------------------------------------------------
+// Custom formatters for specific integrations
+// ---------------------------------------------------------------------------
+function formatAlgolia(doc) {
+    const lines = [];
+    const enabled = doc.enabled === true;
+    lines.push(`Enabled: ${enabled ? "Yes" : "No"}`);
+    const appId = doc.applicationId || "not set";
+    lines.push(`Application ID: ${appId}`);
+    const collections = doc.indexedCollections;
+    if (collections && collections.length > 0) {
+        lines.push(`Indexed collections:`);
+        for (const col of collections) {
+            lines.push(`  - ${col.name || "unnamed"}`);
+        }
+    }
+    else {
+        lines.push(`Indexed collections: none`);
+    }
+    return lines;
+}
+function formatGoogleMaps(doc) {
+    const androidKey = doc.androidKey || "not set";
+    const iosKey = doc.iosKey || "not set";
+    const webKey = doc.webKey || "not set";
+    return [
+        `Android key: ${androidKey}`,
+        `iOS key: ${iosKey}`,
+        `Web key: ${webKey}`,
+    ];
+}
+function formatFirebaseAnalytics(doc) {
+    const lines = [];
+    const enabled = doc.enabled === true;
+    lines.push(`Enabled: ${enabled ? "Yes" : "No"}`);
+    const settings = doc.automaticEventSettings;
+    if (settings) {
+        lines.push(`Automatic event settings:`);
+        lines.push(`  onPageLoad: ${settings.onPageLoad === true ? "Yes" : "No"}`);
+        lines.push(`  onActionsStart: ${settings.onActionsStart === true ? "Yes" : "No"}`);
+        lines.push(`  onAuth: ${settings.onAuth === true ? "Yes" : "No"}`);
+    }
+    return lines;
+}
+/**
+ * Generic formatter: shows `enabled` status and all non-sensitive
+ * top-level string/boolean fields.
+ */
+function formatGeneric(doc) {
+    const lines = [];
+    if ("enabled" in doc) {
+        lines.push(`Enabled: ${doc.enabled === true ? "Yes" : "No"}`);
+    }
+    for (const [key, value] of Object.entries(doc)) {
+        if (key === "enabled")
+            continue;
+        if (SENSITIVE_KEYS.has(key))
+            continue;
+        if (typeof value === "string" || typeof value === "boolean") {
+            lines.push(`${key}: ${typeof value === "boolean" ? (value ? "Yes" : "No") : value}`);
+        }
+    }
+    return lines;
+}
+// ---------------------------------------------------------------------------
+// Integration list — order matches the spec
+// ---------------------------------------------------------------------------
+const INTEGRATIONS = [
+    { fileKey: "supabase", displayName: "Supabase" },
+    { fileKey: "sqlite", displayName: "SQLite" },
+    { fileKey: "github", displayName: "GitHub" },
+    { fileKey: "algolia", displayName: "Algolia", format: formatAlgolia },
+    { fileKey: "firebase-analytics", displayName: "Google Analytics", format: formatFirebaseAnalytics },
+    { fileKey: "google-maps", displayName: "Google Maps", format: formatGoogleMaps },
+    { fileKey: "admob", displayName: "AdMob" },
+    { fileKey: "mux", displayName: "Mux Livestream" },
+    { fileKey: "onesignal", displayName: "OneSignal" },
+    { fileKey: "gemini", displayName: "Gemini" },
+];
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGetIntegrationsTool(server) {
+    server.tool("get_integrations", "Get Integrations settings — Supabase, SQLite, GitHub, Algolia, Google Analytics, Google Maps, AdMob, Mux Livestream, OneSignal, Gemini. Mirrors the FlutterFlow 'Integrations' section. Cache-based, no API calls. Run sync_project first.", {
+        projectId: z.string().describe("The FlutterFlow project ID"),
+    }, async ({ projectId }) => {
+        const meta = await cacheMeta(projectId);
+        if (!meta) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No cache found for project "${projectId}". Run sync_project first.`,
+                    },
+                ],
+            };
+        }
+        // Read all integration files in parallel
+        const rawResults = await Promise.all(INTEGRATIONS.map((def) => cacheRead(projectId, def.fileKey)));
+        const sections = ["# Integrations"];
+        for (let i = 0; i < INTEGRATIONS.length; i++) {
+            const def = INTEGRATIONS[i];
+            const raw = rawResults[i];
+            sections.push(`\n## ${def.displayName}`);
+            if (!raw) {
+                sections.push("(not configured)");
+                continue;
+            }
+            const doc = YAML.parse(raw);
+            const formatter = def.format || formatGeneric;
+            const lines = formatter(doc);
+            sections.push(lines.join("\n"));
+        }
+        return {
+            content: [{ type: "text", text: sections.join("\n") }],
+        };
+    });
+}

package/build/tools/get-project-setup.d.ts

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

package/build/tools/get-project-setup.js

@@ -0,0 +1,212 @@
+import { z } from "zod";
+import YAML from "yaml";
+import { cacheRead, cacheMeta } from "../utils/cache.js";
+import { resolveDataType } from "../utils/resolve-data-type.js";
+export function registerGetProjectSetupTool(server) {
+    server.tool("get_project_setup", "Get Project Setup settings — Firebase services, Languages, Platforms, Permissions, Project Dependencies, Dev Environments. Mirrors the FlutterFlow 'Project Setup' settings section. Cache-based, no API calls. Run sync_project first.", {
+        projectId: z.string().describe("The FlutterFlow project ID"),
+    }, async ({ projectId }) => {
+        const meta = await cacheMeta(projectId);
+        if (!meta) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No cache found for project "${projectId}". Run sync_project first.`,
+                    },
+                ],
+            };
+        }
+        const [analyticsRaw, appCheckRaw, crashlyticsRaw, perfMonRaw, remoteConfigRaw, languagesRaw, platformsRaw, permissionsRaw, dependenciesRaw, customCodeDepsRaw, envSettingsRaw,] = await Promise.all([
+            cacheRead(projectId, "firebase-analytics"),
+            cacheRead(projectId, "firebase-app-check"),
+            cacheRead(projectId, "firebase-crashlytics"),
+            cacheRead(projectId, "firebase-performance-monitoring"),
+            cacheRead(projectId, "firebase-remote-config"),
+            cacheRead(projectId, "languages"),
+            cacheRead(projectId, "platforms"),
+            cacheRead(projectId, "permissions"),
+            cacheRead(projectId, "dependencies"),
+            cacheRead(projectId, "custom-code-dependencies"),
+            cacheRead(projectId, "environment-settings"),
+        ]);
+        const sections = ["# Project Setup"];
+        // --- Firebase ---
+        sections.push(`\n## Firebase`);
+        const anyFirebase = analyticsRaw || appCheckRaw || crashlyticsRaw || perfMonRaw || remoteConfigRaw;
+        if (anyFirebase) {
+            // Analytics
+            if (analyticsRaw) {
+                const analytics = YAML.parse(analyticsRaw);
+                const enabled = analytics.enabled === true;
+                sections.push(`Analytics: ${enabled ? "enabled" : "disabled"}`);
+                if (enabled) {
+                    const eventSettings = analytics.automaticEventSettings;
+                    if (eventSettings) {
+                        sections.push(`  onPageLoad: ${eventSettings.onPageLoad === true ? "Yes" : "No"}`, `  onActionsStart: ${eventSettings.onActionsStart === true ? "Yes" : "No"}`, `  onAuth: ${eventSettings.onAuth === true ? "Yes" : "No"}`);
+                    }
+                }
+            }
+            // App Check
+            if (appCheckRaw) {
+                const appCheck = YAML.parse(appCheckRaw);
+                sections.push(`App Check: ${appCheck.enabled === true ? "enabled" : "disabled"}`);
+            }
+            // Crashlytics
+            if (crashlyticsRaw) {
+                const crashlytics = YAML.parse(crashlyticsRaw);
+                sections.push(`Crashlytics: ${crashlytics.enabled === true ? "enabled" : "disabled"}`);
+            }
+            // Performance Monitoring
+            if (perfMonRaw) {
+                const perfMon = YAML.parse(perfMonRaw);
+                sections.push(`Performance Monitoring: ${perfMon.enabled === true ? "enabled" : "disabled"}`);
+            }
+            // Remote Config
+            if (remoteConfigRaw) {
+                const remoteConfig = YAML.parse(remoteConfigRaw);
+                const enabled = remoteConfig.enabled === true;
+                sections.push(`Remote Config: ${enabled ? "enabled" : "disabled"}`);
+                if (enabled) {
+                    const fields = remoteConfig.fields || [];
+                    if (fields.length > 0) {
+                        sections.push(`  Fields:`);
+                        for (const field of fields) {
+                            const name = field.parameter?.identifier?.name || "unknown";
+                            const dt = resolveDataType(field.parameter?.dataType || {});
+                            const defaultVal = field.serializedDefaultValue ?? "";
+                            sections.push(`    - ${name}: ${dt} (default: "${defaultVal}")`);
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            sections.push(`(not configured)`);
+        }
+        // --- Languages ---
+        sections.push(`\n## Languages`);
+        if (languagesRaw) {
+            const langs = YAML.parse(languagesRaw);
+            const primaryLang = langs.primaryLanguage
+                ?.language;
+            const displayLang = langs.displayLanguage
+                ?.language;
+            const allLangs = langs.languages || [];
+            sections.push(`Primary: ${primaryLang || "not set"}`);
+            sections.push(`Display: ${displayLang || "not set"}`);
+            if (allLangs.length > 0) {
+                const langCodes = allLangs.map((l) => l.language).join(", ");
+                sections.push(`Available: ${langCodes}`);
+            }
+        }
+        else {
+            sections.push(`(not configured)`);
+        }
+        // --- Platforms ---
+        sections.push(`\n## Platforms`);
+        if (platformsRaw) {
+            const platforms = YAML.parse(platformsRaw);
+            sections.push(`Web: ${platforms.enableWeb === true ? "enabled" : "disabled"}`);
+        }
+        else {
+            sections.push(`(not configured)`);
+        }
+        // --- Permissions ---
+        sections.push(`\n## Permissions`);
+        if (permissionsRaw) {
+            const permissions = YAML.parse(permissionsRaw);
+            const builtIn = permissions.permissionMessages;
+            const custom = permissions.userDefinedPermissions;
+            const hasBuiltIn = builtIn && builtIn.length > 0;
+            const hasCustom = custom && custom.length > 0;
+            if (hasBuiltIn || hasCustom) {
+                if (hasBuiltIn) {
+                    sections.push(`Built-in:`);
+                    for (const perm of builtIn) {
+                        const permType = perm.permissionType || "UNKNOWN";
+                        const msg = perm.message?.textValue?.inputValue;
+                        sections.push(`  - ${permType}: ${msg ? `"${msg}"` : "(no message)"}`);
+                    }
+                }
+                if (hasCustom) {
+                    sections.push(`Custom:`);
+                    for (const perm of custom) {
+                        const names = perm.names;
+                        const iosName = names?.iosName || "?";
+                        const androidName = names?.androidName || "?";
+                        const msg = perm.message?.textValue?.inputValue;
+                        sections.push(`  - ${iosName} / ${androidName}: ${msg ? `"${msg}"` : "(no message)"}`);
+                    }
+                }
+            }
+            else {
+                sections.push(`(not configured)`);
+            }
+        }
+        else {
+            sections.push(`(not configured)`);
+        }
+        // --- Project Dependencies ---
+        sections.push(`\n## Project Dependencies`);
+        const hasDeps = dependenciesRaw || customCodeDepsRaw;
+        if (hasDeps) {
+            // FF library dependencies
+            if (dependenciesRaw) {
+                const deps = YAML.parse(dependenciesRaw);
+                const libDeps = deps.dependencies || [];
+                if (libDeps.length > 0) {
+                    sections.push(`FF Libraries:`);
+                    for (const dep of libDeps) {
+                        sections.push(`  - ${dep.name || "unnamed"} (${dep.projectId || "?"}, version: ${dep.version || "?"})`);
+                    }
+                }
+            }
+            // Pubspec dependencies
+            if (customCodeDepsRaw) {
+                const customDeps = YAML.parse(customCodeDepsRaw);
+                const pubspecDeps = customDeps.pubspecDependencies || [];
+                if (pubspecDeps.length > 0) {
+                    sections.push(`Pubspec Dependencies:`);
+                    for (const dep of pubspecDeps) {
+                        sections.push(`  - ${dep.name || "unnamed"}: ${dep.version || "any"}`);
+                    }
+                }
+            }
+        }
+        else {
+            sections.push(`(not configured)`);
+        }
+        // --- Dev Environments ---
+        sections.push(`\n## Dev Environments`);
+        if (envSettingsRaw) {
+            const doc = YAML.parse(envSettingsRaw);
+            const currentEnv = doc.currentEnvironment;
+            const envValues = doc.environmentValues || [];
+            if (currentEnv) {
+                sections.push(`Current: ${currentEnv.name || "unknown"} (${currentEnv.key || "?"})`);
+            }
+            const lines = [];
+            for (const ev of envValues) {
+                const name = ev.parameter?.identifier?.name || "unknown";
+                const dt = resolveDataType(ev.parameter?.dataType || {});
+                const privateTag = ev.isPrivate ? " (private)" : "";
+                lines.push(`- ${name}: ${dt}${privateTag}`);
+                const valuesMap = ev.valuesMap || {};
+                for (const [envKey, envVal] of Object.entries(valuesMap)) {
+                    const display = ev.isPrivate ? "****" : (envVal.serializedValue ?? "");
+                    lines.push(`  ${envKey}: ${display}`);
+                }
+            }
+            if (lines.length > 0) {
+                sections.push(lines.join("\n"));
+            }
+        }
+        else {
+            sections.push(`(not configured)`);
+        }
+        return {
+            content: [{ type: "text", text: sections.join("\n") }],
+        };
+    });
+}

package/build/tools/get-yaml-docs.js

@@ -1,115 +1,5 @@
 import { z } from "zod";
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const DOCS_DIR = path.resolve(__dirname, "../../docs/ff-yaml");
-/** Topic-to-file mapping for fuzzy search. */
-const TOPIC_MAP = {
-    // Widgets
-    button: "04-widgets/button.md",
-    iconbutton: "04-widgets/button.md",
-    text: "04-widgets/text.md",
-    richtext: "04-widgets/text.md",
-    richtextspan: "04-widgets/text.md",
-    textfield: "04-widgets/text-field.md",
-    "text-field": "04-widgets/text-field.md",
-    input: "04-widgets/text-field.md",
-    container: "04-widgets/container.md",
-    boxdecoration: "04-widgets/container.md",
-    column: "04-widgets/layout.md",
-    row: "04-widgets/layout.md",
-    stack: "04-widgets/layout.md",
-    wrap: "04-widgets/layout.md",
-    layout: "04-widgets/layout.md",
-    image: "04-widgets/image.md",
-    form: "04-widgets/form.md",
-    validation: "04-widgets/form.md",
-    dropdown: "04-widgets/dropdown.md",
-    choicechips: "04-widgets/dropdown.md",
-    icon: "04-widgets/misc.md",
-    progressbar: "04-widgets/misc.md",
-    appbar: "04-widgets/misc.md",
-    conditionalbuilder: "04-widgets/misc.md",
-    widget: "04-widgets/README.md",
-    widgets: "04-widgets/README.md",
-    // Non-widget topics
-    actions: "05-actions.md",
-    action: "05-actions.md",
-    trigger: "05-actions.md",
-    navigate: "05-actions.md",
-    navigation: "05-actions.md",
-    ontap: "05-actions.md",
-    variables: "06-variables.md",
-    variable: "06-variables.md",
-    binding: "06-variables.md",
-    "data-binding": "06-variables.md",
-    data: "07-data.md",
-    collections: "07-data.md",
-    firestore: "07-data.md",
-    api: "07-data.md",
-    custom: "08-custom-code.md",
-    dart: "08-custom-code.md",
-    "custom-code": "08-custom-code.md",
-    theme: "09-theming.md",
-    theming: "09-theming.md",
-    color: "09-theming.md",
-    colors: "09-theming.md",
-    font: "09-theming.md",
-    typography: "09-theming.md",
-    editing: "10-editing-guide.md",
-    workflow: "10-editing-guide.md",
-    "editing-guide": "10-editing-guide.md",
-    push: "10-editing-guide.md",
-    overview: "00-overview.md",
-    structure: "00-overview.md",
-    "project-files": "01-project-files.md",
-    config: "01-project-files.md",
-    settings: "01-project-files.md",
-    pages: "02-pages.md",
-    page: "02-pages.md",
-    scaffold: "02-pages.md",
-    components: "03-components.md",
-    component: "03-components.md",
-    createcomponent: "03-components.md",
-    refactor: "03-components.md",
-    refactoring: "03-components.md",
-    isdummyroot: "03-components.md",
-    dummyroot: "03-components.md",
-    componentclasskeyref: "03-components.md",
-    parametervalues: "03-components.md",
-    callback: "03-components.md",
-    executecallbackaction: "03-components.md",
-    // Universal patterns
-    inputvalue: "README.md",
-    mostrecentinputvalue: "README.md",
-    padding: "README.md",
-    "border-radius": "README.md",
-};
-/** List all doc files recursively. */
-function listDocFiles(dir, prefix = "") {
-    const results = [];
-    if (!fs.existsSync(dir))
-        return results;
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.isDirectory()) {
-            results.push(...listDocFiles(path.join(dir, entry.name), relPath));
-        }
-        else if (entry.name.endsWith(".md")) {
-            results.push(relPath);
-        }
-    }
-    return results;
-}
-/** Read a doc file. Returns null if not found. */
-function readDoc(relPath) {
-    const filePath = path.join(DOCS_DIR, relPath);
-    if (!fs.existsSync(filePath))
-        return null;
-    return fs.readFileSync(filePath, "utf-8");
-}
+import { TOPIC_MAP, DOCS_DIR, listDocFiles, readDoc } from "../utils/topic-map.js";
 export function registerGetYamlDocsTool(server) {
     server.tool("get_yaml_docs", "Search and retrieve FlutterFlow YAML reference documentation. Use `topic` to search by keyword (e.g. 'Button', 'actions', 'theming') or `file` to fetch a specific doc file. Returns the full doc content.", {
         topic: z