@rebasepro/plugin-ai 0.12.1-canary.gf5f1d39 → 0.13.0

package/src/types/data_enhancement_controller.tsx

@@ -1,64 +1,131 @@
 import { EntityValues } from "@rebasepro/types";
 import { EditorAIController } from "@rebasepro/admin";
 
-export type EnhanceParams<M extends Record<string, unknown>> = {
-    entityId?: string | number;
+export type GenerateParams<M extends Record<string, unknown>> = {
+    values: EntityValues<M>;
+    /** Free-text instruction from the operator, if they gave one. */
+    instructions?: string;
+    /** Restrict the run to one field. */
     propertyKey?: string;
     propertyInstructions?: string;
-    values: EntityValues<M>;
+};
+
+/**
+ * One field the model wants to write, awaiting the operator's decision.
+ *
+ * Nothing here has touched the form. That is the entire point of the type: the
+ * previous design streamed generated text straight into the live fields, which
+ * meant a half-written sentence was indistinguishable from a bug, the
+ * operator's own words were overwritten by heuristics that tried to guess
+ * whether to append or replace, and there was no way back other than retyping.
+ */
+export type ProposedField = {
+    /** Dotted property path, e.g. `seo.title`. */
+    key: string;
+    /** The property's display name, falling back to its key. */
+    label: string;
+    /** What is in the form right now — shown so an overwrite is visible. */
+    currentValue: unknown;
+    /** What the model proposes. Grows while `pending`. */
+    proposed: unknown;
+    /** Still streaming. */
+    pending: boolean;
+    /** Whether Apply will write this one. */
+    selected: boolean;
+};
+
+export type AutofillReview = {
+    status: "generating" | "ready" | "failed";
+    /** Set when `status` is `failed`. */
+    error?: string;
+    /** In arrival order, so the list reads as the model works. */
+    fields: ProposedField[];
+    /** What was asked for, shown back to the operator while they review. */
     instructions?: string;
-    replaceValues: boolean;
 };
 
 export type DataEnhancementController = {
     /**
-     * Whether the data enhancement is enabled for the current path
+     * Whether autofill can actually be used right now.
+     *
+     * The conjunction of two separate things: the host app allows it for this
+     * collection ({@link DataEnhancementPluginProps.getConfigForPath}), *and*
+     * the service reported itself available. The second half is what the
+     * FireCMS-era plugin lacked — it rendered its button unconditionally
+     * against a host that no longer existed, so every click 404'd.
      */
     enabled: boolean;
-    suggestions: Record<string, string | number>;
-    enhance: <M extends Record<string, unknown>>(props: EnhanceParams<M>) => Promise<EnhancedDataResult | null>;
-    clearSuggestion: (key: string, suggestion: string | number) => void;
-    allowReferenceDataSelection: boolean;
-    clearAllSuggestions: () => void;
+
+    /** The run in flight or awaiting review; `null` when there is neither. */
+    review: AutofillReview | null;
+
+    /** Start a run. Opens {@link review}; never writes to the form. */
+    generate: <M extends Record<string, unknown>>(params: GenerateParams<M>) => Promise<void>;
+
+    /** Include or exclude one field from what Apply will write. */
+    toggleField: (key: string) => void;
+
+    /** Select or deselect every field at once. */
+    toggleAll: (selected: boolean) => void;
+
+    /**
+     * Write the selected fields to the form and close the review.
+     *
+     * The only path by which this plugin mutates a record, and it runs once per
+     * run rather than once per token — so it is a single undo step and a single
+     * dirty transition, not hundreds.
+     */
+    applyReview: () => void;
+
+    /** Close the review, writing nothing. The record is untouched. */
+    dismissReview: () => void;
+
     getSamplePrompts: (entityName: string, input?: string) => Promise<SamplePromptsResult>;
-    loadingSuggestions: string[],
+
     editorAIController?: EditorAIController;
-}
+};
 
-export type EnhancedDataResult = {
-    entityId?: string | number;
-    suggestions: {
-        [key: string]: string[];
-    };
-    errors: string[];
-    usage: { promptTokens?: number, completionTokens?: number, totalTokens?: number }
-}
+/** What `GET /status` answers. Everything else is gated on `available`. */
+export type AiStatus = {
+    available: boolean;
+    model?: string;
+    features?: string[];
+};
+
+export type AutofillResult = {
+    /** Every field the service completed, keyed by property path. */
+    suggestions: Record<string, unknown>;
+    usage?: { inputTokens?: number; outputTokens?: number };
+};
 
 export type SamplePrompt = {
     prompt: string;
     type: "recent" | "sample";
-}
+};
 
 export type SamplePromptsResult = {
     prompts: SamplePrompt[];
-    host?: string;
 };
 
-export type DataEnhancementRequest = {
+/**
+ * The autofill request body.
+ *
+ * The property schema travels with every request because the service has no
+ * access to the caller's collections — it is a hosted endpoint reachable from
+ * any self-hosted admin panel. That is the cost of not putting an LLM
+ * dependency in `@rebasepro/server`; had the route lived in the backend it
+ * could have read the collection registry and this would be three fields.
+ */
+export type AutofillRequest = {
     entityName: string;
     entityDescription?: string;
-    inputEntity: InputEntity;
+    values: Record<string, unknown>;
     properties: Record<string, InputProperty>;
     propertyKey?: string;
-    propertyInstructions?: string,
+    propertyInstructions?: string;
     instructions?: string;
 };
 
-export type InputEntity = {
-    entityId?: string | number;
-    values: Record<string, any>;
-};
-
 export type InputProperty = {
     name?: string;
     description?: string;
@@ -72,4 +139,4 @@ export type InputProperty = {
         typeField?: string;
         valueField?: string;
     };
-}
+};

package/src/useDataEnhancementPlugin.tsx

@@ -5,17 +5,12 @@ import { RebasePlugin } from "@rebasepro/admin-types";
 import { DataEnhancementControllerProvider } from "./components/DataEnhancementControllerProvider";
 import { FormEnhanceAction } from "./components/FormEnhanceAction";
 
-const DEFAULT_API_KEY = "fcms-U9jdDii0xXWSDC34asfrf54lbkFJBfKfRWcEDEwdc4V5wDWEDF";
-
 export interface DataEnhancementPluginProps {
 
-    apiKey?: string;
-
     /**
      * Use this function to determine if the data enhancement plugin should be enabled for a given path.
      * If this function is not provided, the plugin will be enabled for all paths.
      * If the function returns false, the plugin will be disabled for the given path.
-     * You can also return a configuration object to override the default configuration.
      *
      * @param path
      * @param collection
@@ -27,10 +22,17 @@ export interface DataEnhancementPluginProps {
     }) => boolean;
 
     /**
-     * Host to use for the data enhancement API.
-     * This prop is only use in development mode.
+     * Base URL of the AI service.
+     *
+     * Defaults to the one Rebase hosts, which is free to use and needs no
+     * configuration. Point it at your own deployment to keep generation inside
+     * your infrastructure — the wire format is documented in `src/api.ts`, and
+     * the reference implementation is `saas/backend/functions/ai.ts`.
+     *
+     * Whatever it points at, the plugin renders nothing until that host's
+     * `GET /status` reports itself available.
      */
-    host?: string;
+    endpoint?: string;
 }
 
 /**
@@ -40,8 +42,8 @@ export interface DataEnhancementPluginProps {
  */
 export function useDataEnhancementPlugin(props?: DataEnhancementPluginProps): RebasePlugin {
 
-    const apiKey = props?.apiKey ?? DEFAULT_API_KEY;
     const getConfigForPath = props?.getConfigForPath;
+    const endpoint = props?.endpoint;
 
     return React.useMemo(() => ({
         key: "data_enhancement",
@@ -57,11 +59,10 @@ export function useDataEnhancementPlugin(props?: DataEnhancementPluginProps): Re
                 scope: "form" as const,
                 Component: DataEnhancementControllerProvider as React.ComponentType<any>,
                 props: {
-                    apiKey,
                     getConfigForPath,
-                    host: props?.host
+                    endpoint
                 }
             }
         ]
-    }), [apiKey, getConfigForPath, props?.host]);
+    }), [getConfigForPath, endpoint]);
 }

package/dist/utils/diffStrings.d.ts

@@ -1,7 +0,0 @@
-type ChangeType = "equal" | "delete" | "insert";
-export interface Change {
-    type: ChangeType;
-    value: string;
-}
-export declare function diffStrings(oldStr: string, newStr: string): Change[];
-export {};

package/dist/utils/strings_counter.d.ts

@@ -1,2 +0,0 @@
-import { EntityValues, Properties } from "@rebasepro/types";
-export declare function countStringCharacters(values: EntityValues<any>, properties: Properties): number;

package/dist/utils/suggestions.d.ts

@@ -1 +0,0 @@
-export declare function getAppendableSuggestion(suggestion: string | number | undefined, value: unknown): string | undefined;

package/src/tests/diffStrings.test.ts

@@ -1,128 +0,0 @@
-// Import the diffStrings function from your module
-// import { diffStrings } from './your-module';
-
-import { Change, diffStrings } from "../utils/diffStrings";
-
-describe("diffStrings", () => {
-    test("equal strings", () => {
-        const oldStr = "This is a test string";
-        const newStr = "This is a test string";
-        const expected: Change[] = [
-            {
-                type: "equal",
-                value: "This is a test string"
-            }
-        ];
-        expect(diffStrings(oldStr, newStr)).toEqual(expected);
-    });
-
-    test("insertions only", () => {
-        const oldStr = "This is a test string";
-        const newStr = "This is a new test string";
-        const expected: Change[] = [
-            {
-                type: "equal",
-                value: "This is a"
-            },
-            {
-                type: "insert",
-                value: " new"
-            },
-            {
-                type: "equal",
-                value: " test string"
-            }
-        ];
-        expect(diffStrings(oldStr, newStr)).toEqual(expected);
-    });
-
-    test("deletions only", () => {
-        const oldStr = "This is an old test string";
-        const newStr = "This is a test string";
-        const expected: Change[] = [
-            {
-                type: "equal",
-                value: "This is a"
-            },
-            {
-                type: "delete",
-                value: "n old"
-            },
-            {
-                type: "equal",
-                value: " test string"
-            }
-        ];
-        expect(diffStrings(oldStr, newStr)).toEqual(expected);
-    });
-
-    test("insertions and deletions", () => {
-        const oldStr = "This is an old test string";
-        const newStr = "This is a new modified test string";
-        // The LCS algorithm finds the longest common substrings correctly
-        // Even though the output is more granular, it correctly represents the diff
-        const expected: Change[] = [
-            {
-                type: "equal",
-                value: "This is a"
-            },
-            {
-                type: "insert",
-                value: " "
-            },
-            {
-                type: "equal",
-                value: "n"
-            },
-            {
-                type: "insert",
-                value: "ew"
-            },
-            {
-                type: "equal",
-                value: " "
-            },
-            {
-                type: "insert",
-                value: "m"
-            },
-            {
-                type: "equal",
-                value: "o"
-            },
-            {
-                type: "delete",
-                value: "l"
-            },
-            {
-                type: "insert",
-                value: "difie"
-            },
-            {
-                type: "equal",
-                value: "d test string"
-            }
-        ];
-        expect(diffStrings(oldStr, newStr)).toEqual(expected);
-    });
-
-    test("completely different strings", () => {
-        const oldStr = "Old string";
-        const newStr = "New string";
-        const expected: Change[] = [
-            {
-                type: "delete",
-                value: "Old"
-            },
-            {
-                type: "insert",
-                value: "New"
-            },
-            {
-                type: "equal",
-                value: " string"
-            }
-        ];
-        expect(diffStrings(oldStr, newStr)).toEqual(expected);
-    });
-});

package/src/tests/strings_counter.test.ts

@@ -1,117 +0,0 @@
-import { countStringCharacters } from "../utils/strings_counter";
-import type { Properties } from "@rebasepro/types";
-
-describe("countStringCharacters", () => {
-    it("counts characters in a string property", () => {
-        const values = { title: "Hello World" };
-        const properties: Properties = {
-            title: { name: "title",
-type: "string" }
-        };
-        expect(countStringCharacters(values, properties)).toBe(11);
-    });
-
-    it("counts characters in a number property (stringified)", () => {
-        const values = { price: 12345 };
-        const properties: Properties = {
-            price: { name: "price",
-type: "number" }
-        };
-        expect(countStringCharacters(values, properties)).toBe(5);
-    });
-
-    it("skips disabled properties", () => {
-        const values = { title: "Hello",
-hidden: "Secret" };
-        const properties: Properties = {
-            title: { name: "title",
-type: "string" },
-            hidden: { name: "hidden",
-type: "string",
-admin: { disabled: true } }
-        };
-        expect(countStringCharacters(values, properties)).toBe(5);
-    });
-
-    it("counts array of strings", () => {
-        const values = { tags: ["hello", "world", "test"] };
-        const properties: Properties = {
-            tags: {
-                name: "tags",
-                type: "array",
-                of: { name: "tag",
-type: "string" }
-            }
-        };
-        // "hello" (5) + "world" (5) + "test" (4) = 14
-        expect(countStringCharacters(values, properties)).toBe(14);
-    });
-
-    it("recurses into map properties", () => {
-        const values = {
-            address: { city: "New York",
-country: "USA" }
-        };
-        const properties: Properties = {
-            address: {
-                name: "address",
-                type: "map",
-                properties: {
-                    city: { name: "city",
-type: "string" },
-                    country: { name: "country",
-type: "string" }
-                }
-            }
-        };
-        // "New York" (8) + "USA" (3) = 11
-        expect(countStringCharacters(values, properties)).toBe(11);
-    });
-
-    it("returns 0 for empty values", () => {
-        const properties: Properties = {
-            title: { name: "title",
-type: "string" }
-        };
-        expect(countStringCharacters({}, properties)).toBe(0);
-    });
-
-    it("handles mixed property types", () => {
-        const values = {
-            title: "Hello",
-            count: 42,
-            active: true,
-            tags: ["a", "bb"]
-        };
-        const properties: Properties = {
-            title: { name: "title",
-type: "string" },
-            count: { name: "count",
-type: "number" },
-            active: { name: "active",
-type: "boolean" },
-            tags: {
-                name: "tags",
-                type: "array",
-                of: { name: "tag",
-type: "string" }
-            }
-        };
-        // "Hello" (5) + "42" (2) + "a" (1) + "bb" (2) = 10
-        expect(countStringCharacters(values, properties)).toBe(10);
-    });
-
-    it("handles null values in array gracefully", () => {
-        const values = { tags: [null, "hello", null] };
-        const properties: Properties = {
-            tags: {
-                name: "tags",
-                type: "array",
-                of: { name: "tag",
-type: "string" }
-            }
-        };
-        // null?.length = 0, "hello" = 5, null?.length = 0
-        expect(countStringCharacters(values, properties)).toBe(5);
-    });
-});

package/src/tests/suggestions.test.ts

@@ -1,53 +0,0 @@
-import { getAppendableSuggestion } from "../utils/suggestions";
-
-describe("getAppendableSuggestion", () => {
-    it("returns the remaining part when suggestion starts with value", () => {
-        const result = getAppendableSuggestion("Hello World", "Hello");
-        expect(result).toBe(" World");
-    });
-
-    it("returns undefined when suggestion does not start with value", () => {
-        const result = getAppendableSuggestion("Goodbye World", "Hello");
-        expect(result).toBeUndefined();
-    });
-
-    it("performs case-insensitive matching", () => {
-        const result = getAppendableSuggestion("Hello World", "hello");
-        expect(result).toBe(" World");
-    });
-
-    it("returns undefined for number suggestion", () => {
-        const result = getAppendableSuggestion(42, "4");
-        expect(result).toBeUndefined();
-    });
-
-    it("returns undefined for undefined suggestion", () => {
-        const result = getAppendableSuggestion(undefined, "hello");
-        expect(result).toBeUndefined();
-    });
-
-    it("returns undefined for non-string value", () => {
-        const result = getAppendableSuggestion("Hello", 42);
-        expect(result).toBeUndefined();
-    });
-
-    it("returns full suggestion when value is empty string", () => {
-        const result = getAppendableSuggestion("Hello World", "");
-        expect(result).toBe("Hello World");
-    });
-
-    it("handles whitespace trimming", () => {
-        const result = getAppendableSuggestion("Hello World", "Hello");
-        expect(result).toBe(" World");
-    });
-
-    it("returns empty string when suggestion equals value", () => {
-        const result = getAppendableSuggestion("Hello", "Hello");
-        expect(result).toBe("");
-    });
-
-    it("returns undefined when value is longer than suggestion", () => {
-        const result = getAppendableSuggestion("Hi", "Hello World");
-        expect(result).toBeUndefined();
-    });
-});

package/src/utils/diffStrings.ts

@@ -1,70 +0,0 @@
-type ChangeType = "equal" | "delete" | "insert";
-
-export interface Change {
-    type: ChangeType;
-    value: string;
-}
-
-export function diffStrings(oldStr: string, newStr: string): Change[] {
-    // Find the longest common substring
-    function longestCommonSubstring(s1: string, s2: string): string {
-        const longest = { start: 0,
-length: 0 };
-        const matrix = new Array(s1.length + 1).fill(null).map(() => new Array(s2.length + 1).fill(0));
-
-        for (let i = 1; i <= s1.length; i++) {
-            for (let j = 1; j <= s2.length; j++) {
-                if (s1[i - 1] === s2[j - 1]) {
-                    matrix[i][j] = matrix[i - 1][j - 1] + 1;
-                    if (matrix[i][j] > longest.length) {
-                        longest.start = i - matrix[i][j];
-                        longest.length = matrix[i][j];
-                    }
-                }
-            }
-        }
-
-        return s1.slice(longest.start, longest.start + longest.length);
-    }
-
-    // Recursively find changes and create Change objects
-    function findChanges(s1: string, s2: string): Change[] {
-        if (s1 === s2) return s1.length > 0 ? [{
-            type: "equal",
-            value: s1
-        }] : [];
-
-        const common = longestCommonSubstring(s1, s2);
-
-        if (common.length === 0) {
-            const changes: Change[] = [];
-            if (s1.length > 0) {
-                changes.push({ type: "delete",
-value: s1 });
-            }
-            if (s2.length > 0) {
-                changes.push({ type: "insert",
-value: s2 });
-            }
-            return changes;
-        }
-
-        const s1Before = s1.slice(0, s1.indexOf(common));
-        const s1After = s1.slice(s1.indexOf(common) + common.length);
-        const s2Before = s2.slice(0, s2.indexOf(common));
-        const s2After = s2.slice(s2.indexOf(common) + common.length);
-
-        const changesBefore = findChanges(s1Before, s2Before);
-        const changesAfter = findChanges(s1After, s2After);
-
-        return [
-            ...changesBefore,
-            { type: "equal",
-value: common },
-            ...changesAfter
-        ];
-    }
-
-    return findChanges(oldStr, newStr);
-}
-

package/src/utils/strings_counter.ts

@@ -1,22 +0,0 @@
-import { EntityValues, Properties, Property } from "@rebasepro/types";
-
-export function countStringCharacters(values: EntityValues<any>, properties: Properties) {
-    let count = 0;
-
-    for (const key in values) {
-        const value = values[key];
-        const property: Property = properties[key];
-
-        if (property && !property.admin?.disabled) {
-            if (property.type === "string" || property.type === "number") {
-                count += String(value).length;
-            } else if (property.type === "array" && Array.isArray(value) && property.of && !Array.isArray(property.of) && property.of.type === "string") {
-                count += (value as string[]).reduce((acc, curr) => acc + (curr?.length ?? 0), 0);
-            } else if (property.type === "map" && property.properties && typeof value === "object") {
-                count += countStringCharacters(value, property.properties);
-            }
-        }
-    }
-
-    return count;
-}

package/src/utils/suggestions.ts

@@ -1,6 +0,0 @@
-export function getAppendableSuggestion(suggestion: string | number | undefined, value: unknown): string | undefined {
-    const suggestionIncludesValue = typeof suggestion === "string" && typeof value === "string" && suggestion.toLowerCase().trim().startsWith(value.toLowerCase().trim());
-    return (typeof value === "string" && suggestionIncludesValue)
-        ? suggestion.substring(suggestion.toLowerCase().trim().indexOf(value.toLowerCase().trim()) + value.trim().length)
-        : undefined;
-}