@alpaca-editor/core 1.0.3997 → 1.0.4007

package/src/page-wizard/utils/dataAccessor.ts

@@ -0,0 +1,275 @@
+/**
+ * Utility for flexible data access in wizard steps
+ * Allows both simple property names and JavaScript expressions
+ */
+
+export interface DataAccessResult<T = any> {
+  value: T | undefined;
+  error?: string;
+}
+
+/**
+ * Safely evaluates JavaScript expressions or property accessors against a data object
+ * @param inputProperties - Either a simple property name, a JavaScript expression, or multiple expressions separated by newlines
+ * @param data - The data object to evaluate against
+ * @returns The evaluated value(s) or undefined with an error message
+ */
+export function evaluateDataExpression<T = any>(
+  inputProperties: string,
+  data: any,
+): DataAccessResult<T> {
+  if (!inputProperties) {
+    return { value: undefined };
+  }
+
+  try {
+    // Split by newlines and filter out empty lines
+    const expressionLines = inputProperties
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0);
+
+    // If no valid expressions found, return undefined
+    if (expressionLines.length === 0) {
+      return { value: undefined };
+    }
+
+    // If only one expression, return single result
+    if (expressionLines.length === 1) {
+      const firstExpression = expressionLines[0];
+      if (firstExpression) {
+        return evaluateSingleExpression<T>(firstExpression, data);
+      }
+    }
+
+    // Multiple expressions - evaluate each and collect results
+    const results: any[] = [];
+    const errors: string[] = [];
+
+    for (const expression of expressionLines) {
+      const result = evaluateSingleExpression(expression, data);
+
+      if (result.error) {
+        errors.push(`Line "${expression}": ${result.error}`);
+      } else if (result.value !== undefined) {
+        // Only add non-undefined results
+        if (Array.isArray(result.value)) {
+          results.push(...result.value);
+        } else {
+          results.push(result.value);
+        }
+      }
+    }
+
+    // Return combined results or errors
+    if (errors.length > 0 && results.length === 0) {
+      return {
+        value: undefined,
+        error: `All expressions failed:\n${errors.join("\n")}`,
+      };
+    }
+
+    return {
+      value: results as T,
+      error:
+        errors.length > 0
+          ? `Some expressions failed:\n${errors.join("\n")}`
+          : undefined,
+    };
+  } catch (error) {
+    return {
+      value: undefined,
+      error: `Failed to evaluate expressions "${inputProperties}": ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/**
+ * Evaluates expressions and maps them to object properties
+ * Supports explicit property names (name:expression) and implicit property names (derived from expression)
+ * @param inputProperties - Multiple expressions separated by newlines, optionally with explicit property names
+ * @param data - The data object to evaluate against
+ * @returns Object with properties mapped from expressions
+ */
+export function evaluateDataExpressionToObject(
+  inputProperties: string,
+  data: any,
+): DataAccessResult<Record<string, any>> {
+  if (!inputProperties || !inputProperties.trim()) {
+    return { value: {} };
+  }
+
+  try {
+    // Split by newlines and filter out empty lines
+    const expressionLines = inputProperties
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0);
+
+    if (expressionLines.length === 0) {
+      return { value: {} };
+    }
+
+    const result: Record<string, any> = {};
+    const errors: string[] = [];
+
+    for (const line of expressionLines) {
+      // Check if line contains explicit property name (name:expression format)
+      const colonIndex = line.indexOf(":");
+      let propertyName: string;
+      let expression: string;
+
+      if (colonIndex > 0 && colonIndex < line.length - 1) {
+        // Explicit property name format: "name:expression"
+        propertyName = line.substring(0, colonIndex).trim();
+        expression = line.substring(colonIndex + 1).trim();
+      } else {
+        // Implicit property name - derive from expression
+        expression = line;
+        propertyName = derivePropertyNameFromExpression(expression);
+      }
+
+      // Evaluate the expression
+      const evalResult = evaluateSingleExpression(expression, data);
+
+      if (evalResult.error) {
+        errors.push(
+          `Property "${propertyName}" (${expression}): ${evalResult.error}`,
+        );
+      } else {
+        result[propertyName] = evalResult.value;
+      }
+    }
+
+    return {
+      value: result,
+      error: errors.length > 0 ? errors.join("\n") : undefined,
+    };
+  } catch (error) {
+    return {
+      value: {},
+      error: `Failed to evaluate expressions "${inputProperties}": ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/**
+ * Derives a property name from an expression
+ * Examples:
+ * - "selectedItems" -> "selectedItems"
+ * - "data.selectedItems" -> "selectedItems"
+ * - "data.user.profile.name" -> "name"
+ * - "data.items.filter(x => x.active)" -> "items"
+ */
+function derivePropertyNameFromExpression(expression: string): string {
+  // Remove "data." prefix if present
+  let cleaned = expression.replace(/^data\./, "");
+
+  // For method calls like "items.filter(...)", take the base property
+  const methodMatch = cleaned.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)\./);
+  if (methodMatch && methodMatch[1]) {
+    return methodMatch[1];
+  }
+
+  // For property access like "user.profile.name", take the last property
+  const parts = cleaned.split(".");
+  const lastPart = parts[parts.length - 1];
+
+  if (lastPart) {
+    // Extract just the property name (before any method calls or array access)
+    const propertyMatch = lastPart.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)/);
+    if (propertyMatch && propertyMatch[1]) {
+      return propertyMatch[1];
+    }
+  }
+
+  // Fallback to the first valid identifier in the expression
+  const identifierMatch = cleaned.match(/([a-zA-Z_$][a-zA-Z0-9_$]*)/);
+  return identifierMatch && identifierMatch[1] ? identifierMatch[1] : "result";
+}
+
+/**
+ * Evaluates a single expression
+ */
+function evaluateSingleExpression<T = any>(
+  expression: string,
+  data: any,
+): DataAccessResult<T> {
+  try {
+    // Check if it's a simple property name (no special characters that would indicate JS code)
+    const isSimpleProperty = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(expression);
+
+    if (isSimpleProperty) {
+      // Simple property access
+      return { value: data[expression] };
+    }
+
+    // It's a JavaScript expression
+    // If it doesn't start with "data.", prepend it automatically
+    let processedExpression = expression;
+    if (!expression.trim().startsWith("data.")) {
+      processedExpression = `data.${expression}`;
+    }
+
+    // Create a safe evaluation context
+    const evalFunction = new Function(
+      "data",
+      `
+      try {
+        return ${processedExpression};
+      } catch (error) {
+        throw new Error('Expression evaluation failed: ' + error.message);
+      }
+    `,
+    );
+
+    const result = evalFunction(data);
+    return { value: result };
+  } catch (error) {
+    return {
+      value: undefined,
+      error: `Failed to evaluate expression "${expression}": ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/**
+ * Sets a value in the data object using either a simple property name or a path
+ * For now, this only supports simple property names since setting via expressions is complex
+ * @param propertyName - The property name to set
+ * @param value - The value to set
+ * @param data - The current data object
+ * @returns Updated data object
+ */
+export function setDataProperty(
+  propertyName: string,
+  value: any,
+  data: any,
+): any {
+  // For now, only support simple property names for setting
+  const isSimpleProperty = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(propertyName);
+
+  if (!isSimpleProperty) {
+    console.warn(
+      `Setting data via expressions is not supported yet. Using property name as-is: ${propertyName}`,
+    );
+  }
+
+  return {
+    ...data,
+    [propertyName]: value,
+  };
+}
+
+/**
+ * Hook for using flexible data access in wizard steps
+ * @param expression - The expression or property name to read from
+ * @param data - The current data object
+ * @returns Object with the evaluated value and any error
+ */
+export function useDataExpression<T = any>(
+  expression: string,
+  data: any,
+): DataAccessResult<T> {
+  return evaluateDataExpression<T>(expression, data);
+}

package/src/revision.ts

@@ -1,2 +1,2 @@
-export const version = "1.0.3997";
-export const buildDate = "2025-07-14 01:46:35";
+export const version = "1.0.4007";
+export const buildDate = "2025-07-17 20:54:07";

package/src/splash-screen/RecentPages.tsx

@@ -10,14 +10,25 @@ export function RecentPages() {
   const editContext = useEditContext();
 
   const [history, setHistory] = useState<FullItem[]>();
+  const [isLoading, setIsLoading] = useState(false);
   const [selectedPage, setSelectedPage] = useState<HistoryEntry | null>(null);
 
   const recentPages = editContext?.browseHistory || [];
 
   useEffect(() => {
     const fetchItems = async () => {
-      const pages = await editContext?.itemsRepository.getItems(recentPages);
-      setHistory(pages);
+      if (recentPages.length === 0) {
+        setHistory([]);
+        return;
+      }
+
+      setIsLoading(true);
+      try {
+        const pages = await editContext?.itemsRepository.getItems(recentPages);
+        setHistory(pages);
+      } finally {
+        setIsLoading(false);
+      }
     };
     fetchItems();
   }, [editContext?.itemsRepository, recentPages]);
@@ -105,7 +116,15 @@ export function RecentPages() {
               ))}
             </tbody>
           </table>
-          {(!history || history.length === 0) && (
+          {isLoading && (
+            <div className="flex h-full flex-col items-center justify-center p-6 text-center">
+              <i className="pi pi-spin pi-spinner text-lg text-gray-400"></i>
+              <div className="mt-2 text-sm text-gray-500">
+                Loading recent pages...
+              </div>
+            </div>
+          )}
+          {!isLoading && (!history || history.length === 0) && (
             <div className="p-6 text-center text-sm text-gray-500">
               No recent pages found
             </div>

package/dist/editor/ai/GhostWriter.d.ts

@@ -1 +0,0 @@
-export declare function GhostWriter(): import("react/jsx-runtime").JSX.Element;

package/dist/editor/ai/GhostWriter.js

@@ -1,347 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useEffect, useRef } from "react";
-import { useEditContext } from "../client/editContext";
-import { AiResponseMessage } from "./AiResponseMessage";
-import { createEditorAiContext } from "./editorAiContext";
-import { executePrompt } from "../services/aiService";
-import { useDebouncedCallback } from "use-debounce";
-// Simple debounce function
-function debounce(func, waitFor) {
-    let timeoutId = null;
-    return (...args) => {
-        if (timeoutId !== null) {
-            clearTimeout(timeoutId);
-        }
-        timeoutId = setTimeout(() => func(...args), waitFor);
-    };
-}
-const GHOST_WRITER_CONTEXT_FIELD_ID = "5B14129E-E14F-4C17-A7D2-0FCB27601A18".toLowerCase();
-export function GhostWriter() {
-    const editContext = useEditContext();
-    const [context, setContext] = useState("");
-    const [messages, setMessages] = useState([]);
-    const [thinking, setThinking] = useState(null);
-    const [isMonitoring, setIsMonitoring] = useState(false);
-    const [isThinking, setIsThinking] = useState(false);
-    const lastOpIndexRef = useRef(0);
-    const isMountedRef = useRef(false); // To prevent running on initial mount
-    const [newMessages, setNewMessages] = useState([]);
-    const newMessagesRef = useRef([]);
-    useEffect(() => {
-        newMessagesRef.current = newMessages;
-    }, [newMessages]);
-    // Memoized debounced function
-    const debouncedCheckIfAiCanHelp = useDebouncedCallback(() => {
-        // Check if component is still mounted and conditions are met
-        if (isMountedRef.current && isMonitoring && !isThinking && editContext) {
-            console.log("Debounced check triggered");
-            checkIfAiCanHelp();
-        }
-    }, 3000); // Wait 3 seconds
-    // Effect to monitor edit history length for changes
-    useEffect(() => {
-        if (!editContext || !isMonitoring) {
-            isMountedRef.current = false; // Reset mount status if disabled/no context
-            return;
-        }
-        // Set mounted status only after initial render and when enabled
-        isMountedRef.current = true;
-        // Trigger debounce when edit history changes *after* initial mount
-        // Only trigger if the last edit was NOT made by the AI
-        if (isMountedRef.current && editContext?.editHistory) {
-            const history = editContext.editHistory;
-            if (history.length > 0) {
-                const lastOp = history[0];
-                // Ensure lastOp exists and check the user.ai flag
-                if (lastOp && !lastOp.user?.ai) {
-                    console.log("User edit detected, calling debounce for Ghost Writer check");
-                    debouncedCheckIfAiCanHelp();
-                }
-                else {
-                    console.log("AI edit detected, skipping Ghost Writer check");
-                }
-            }
-        }
-        // Cleanup function to set mounted status to false
-        return () => {
-            isMountedRef.current = false;
-        };
-    }, [editContext?.editHistory, isMonitoring, debouncedCheckIfAiCanHelp]); // Watch history length and monitoring status
-    // Load initial context from Sitecore field and reset state when item changes
-    useEffect(() => {
-        if (!editContext ||
-            !editContext.currentItemDescriptor ||
-            !editContext.itemsRepository) {
-            return;
-        }
-        const { currentItemDescriptor, itemsRepository } = editContext;
-        // Reset all state when item changes
-        setMessages([]);
-        setThinking(null);
-        setIsThinking(false);
-        setNewMessages([]);
-        lastOpIndexRef.current = 0;
-        newMessagesRef.current = [];
-        isMountedRef.current = false;
-        const loadContext = async () => {
-            try {
-                // Get the full item first
-                const item = await itemsRepository.getItem(currentItemDescriptor);
-                if (!item?.fields) {
-                    console.warn("Could not load item or fields for Ghost Writer context");
-                    return;
-                }
-                // Find the specific field
-                const contextField = item.fields.find((f) => f.id === GHOST_WRITER_CONTEXT_FIELD_ID);
-                const initialContext = contextField?.value; // Or contextField?.rawValue
-                if (initialContext && typeof initialContext === "string") {
-                    setContext(initialContext);
-                }
-                else {
-                    // Set to empty if field doesn't exist or is not a string
-                    setContext("");
-                }
-            }
-            catch (error) {
-                console.error("Error loading Ghost Writer context:", error);
-                setContext(""); // Reset context on error
-            }
-        };
-        loadContext();
-        // Depend on the item descriptor and the repository instance
-    }, [editContext?.currentItemDescriptor, editContext?.itemsRepository]);
-    // Debounced function to save context to Sitecore
-    const debouncedSaveContext = useDebouncedCallback((newContext) => {
-        if (!editContext ||
-            !editContext.currentItemDescriptor ||
-            !editContext.operations) {
-            return;
-        }
-        const { currentItemDescriptor, operations } = editContext;
-        console.log("Debounced save triggered for context:", newContext);
-        try {
-            operations.editField({
-                field: {
-                    item: currentItemDescriptor,
-                    fieldId: GHOST_WRITER_CONTEXT_FIELD_ID,
-                },
-                value: newContext,
-            });
-        }
-        catch (error) {
-            console.error("Error saving Ghost Writer context:", error);
-        }
-    }, 1000);
-    // Handle context change and trigger debounced save
-    const handleContextChange = (e) => {
-        const newContext = e.target.value;
-        setContext(newContext);
-        debouncedSaveContext(newContext);
-    };
-    // Function to check if AI can help
-    const checkIfAiCanHelp = async () => {
-        if (!editContext)
-            return;
-        const tasks = [
-            {
-                name: "spell-check",
-                title: "Spell Check",
-                description: "Fix spelling mistakes and grammar errors.",
-            },
-            {
-                name: "find-images",
-                title: "Find Images",
-                description: "Search for matching images and add them to the page.",
-            },
-            {
-                name: "improve-page",
-                title: "Improve Page",
-                description: "If there are no empty fields, you can suggest improvements to the page.",
-            },
-            {
-                name: "support-me",
-                title: "Support Me",
-                description: "Watch for instructions in brackets. Do what I ask you to do and remove the brackets.",
-            },
-        ];
-        console.log("Starting AI check");
-        setIsThinking(true);
-        // Create a new user message for the current context
-        const userMessage = {
-            id: Date.now(),
-            content: context,
-            role: "user",
-            name: "user",
-            tool_calls: [],
-        };
-        // Add user message to our history display
-        const updatedMessages = [...messages, userMessage];
-        setMessages(updatedMessages);
-        setThinking({
-            responseText: "Your Ghost Writer is thinking...",
-            editOperations: [],
-            numInputTokens: 0,
-            numOutputTokens: 0,
-            numCachedTokens: 0,
-            messages: updatedMessages,
-            state: "thinking",
-        });
-        lastOpIndexRef.current = 0;
-        setNewMessages([]);
-        const lockedComponent = editContext.selection.length === 1 &&
-            " The user is editing the component with the id " +
-                editContext.selection[0] +
-                " and is locked. Do not edit this component.";
-        try {
-            // Only send the current context as a message to executePrompt
-            const response = await executePrompt([
-                {
-                    content: "We are together editing this page. You are working in the background and can help us with the following tasks: " +
-                        tasks.map((t) => `- ${t.title}: ${t.description}`).join("\n") +
-                        " Do not interfere with my current work. Dont ask me what you should do. If you are confident your change is welcome, just do it. Do not report progress or changes, just do them. " +
-                        "Do not write empty values into fields. Do not replace a field value with the same value. If you are not sure what the topic is, dont do anything. Do not confirm the instructions, just follow them." +
-                        lockedComponent +
-                        " If you feel you need more information and you cannot find it yourself using the search, ask me specific questions about the topic. " +
-                        " Use the get-component-props-and-placeholders tool to find out which components can be inserted where",
-                    role: "user",
-                    name: "user",
-                },
-            ], editContext, createEditorAiContext, {
-                addAllContent: true,
-                profile: "ghostwriter",
-            }, undefined, "gpt-4.1", handleAiResponse);
-            if (response) {
-                handleAiResponse(response);
-            }
-        }
-        catch (error) {
-            console.error("Error executing Ghost Writer AI prompt:", error);
-            if (isMountedRef.current) {
-                // Check if still mounted before setting state
-                setThinking({
-                    responseText: "Error occurred while thinking.",
-                    editOperations: [],
-                    numInputTokens: 0,
-                    numOutputTokens: 0,
-                    numCachedTokens: 0,
-                    messages: updatedMessages,
-                    state: "error",
-                    toolCalls: [],
-                });
-            }
-        }
-        finally {
-            if (isMountedRef.current) {
-                setIsThinking(false);
-                console.log("AI check finished");
-            }
-        }
-    };
-    // Handle AI response as it streams in
-    const handleAiResponse = (response) => {
-        if (!isMountedRef.current)
-            return; // Don't update state if unmounted
-        // Merge new messages from the response with newMessagesRef.current based on message ID
-        const currentNewMessages = [...newMessagesRef.current];
-        if (response.messages && response.messages.length > 0) {
-            response.messages.forEach((newMsg) => {
-                // Check if message with this ID already exists in newMessages
-                const existingMsgIndex = currentNewMessages.findIndex((m) => m.id === newMsg.id);
-                if (existingMsgIndex >= 0) {
-                    // Update existing message
-                    currentNewMessages[existingMsgIndex] = newMsg;
-                }
-                else {
-                    // Add new message
-                    currentNewMessages.push(newMsg);
-                }
-            });
-        }
-        // Update newMessages state and ref
-        setNewMessages(currentNewMessages);
-        setMessages([...messages, ...currentNewMessages]);
-        // Merge the new response messages with our existing messages
-        const updatedMessages = [...messages];
-        if (response.messages && response.messages.length > 0) {
-            response.messages.forEach((msg) => {
-                updatedMessages.push(msg);
-            });
-        }
-        console.log("Updated messages:", updatedMessages);
-        setMessages(updatedMessages);
-        // Update the response with our combined messages
-        const updatedResponse = {
-            ...response,
-            messages: updatedMessages,
-        };
-        setThinking(updatedResponse); // Update the displayed thinking state
-        // Apply new operations incrementally
-        if (editContext &&
-            response.editOperations &&
-            response.editOperations.length > lastOpIndexRef.current) {
-            const newOps = response.editOperations.slice(lastOpIndexRef.current);
-            //   applyAiOperations(newOps);
-            lastOpIndexRef.current = response.editOperations.length;
-        }
-    };
-    //   // Apply operations suggested by the AI
-    //   const applyAiOperations = (operations: EditOperation[]) => {
-    //     if (!editContext || !isMountedRef.current) return;
-    //     const isEditTextFieldOp = (op: EditOperation): op is EditFieldOperation => {
-    //       if (op.type !== "edit-field") return false;
-    //       const editFieldOp = op as EditFieldOperation;
-    //       return (
-    //         !!editFieldOp.fieldType && editFieldOp.fieldType.indexOf("text") !== -1
-    //       );
-    //     };
-    //     operations.forEach((op: EditOperation) => {
-    //       console.log("Applying AI operation:", op.type, op);
-    //       if (isEditTextFieldOp(op)) {
-    //         if (op.itemId && op.mainItem) {
-    //           // Check mainItem exists
-    //           const fieldDescriptor = {
-    //             item: {
-    //               ...op.mainItem,
-    //               id: op.itemId,
-    //             },
-    //             fieldId: op.fieldId,
-    //           };
-    //           try {
-    //             editContext.itemsRepository.updateFieldValue(
-    //               fieldDescriptor,
-    //               op.user ?? { name: "GhostWriter", ai: true },
-    //               false,
-    //               op.value,
-    //             );
-    //           } catch (error) {
-    //             console.error(
-    //               "Error applying updateFieldValue:",
-    //               error,
-    //               fieldDescriptor,
-    //               op.value,
-    //             );
-    //           }
-    //         } else {
-    //           console.warn(
-    //             "Skipping edit-field op due to missing itemId or mainItem:",
-    //             op,
-    //           );
-    //         }
-    //       } else if (op.type === "add-component") {
-    //         // Add component logic might need more details from the operation
-    //         // Example: editContext.operations.addComponent(...)
-    //         console.warn(
-    //           "Add-component operation application not fully implemented.",
-    //         );
-    //       }
-    //     });
-    //     // Debounce refresh request if needed
-    //     editContext.requestRefresh("immediate");
-    //   };
-    return (_jsxs("div", { className: "ghost-writer flex h-full flex-col gap-4 p-4", children: [_jsxs("div", { className: "flex items-center justify-between", children: [_jsx("h2", { className: "text-lg font-semibold", children: "Ghost Writer" }), _jsxs("label", { className: "flex cursor-pointer items-center", children: [_jsx("input", { type: "checkbox", checked: isMonitoring, onChange: () => setIsMonitoring(!isMonitoring), className: "mr-2" }), _jsx("span", { children: "Enable Ghost Writer" })] })] }), _jsxs("div", { className: "background-context", children: [_jsx("label", { className: "mb-2 block font-medium", children: "Background Context" }), _jsx("textarea", { value: context, onChange: handleContextChange, placeholder: "Provide some background context about this page to help the AI understand its purpose...", className: "h-32 w-full resize-none rounded border p-2", disabled: isThinking })] }), _jsxs("div", { className: "ai-thinking flex-1 overflow-auto text-sm", children: [_jsx("label", { className: "mb-2 block font-medium", children: "AI Thinking" }), _jsxs("div", { className: "max-h-[400px] min-h-[200px] overflow-y-auto rounded border p-3 text-xs", children: [messages.length > 0 ? (_jsx(AiResponseMessage, { messages: messages, editOperations: thinking?.editOperations || [], finished: !thinking ||
-                                    thinking.state === "finished" ||
-                                    thinking.state === "error" })) : (_jsx("div", { className: "text-gray-500 italic", children: isMonitoring
-                                    ? "Ghost Writer is active and monitoring for changes..."
-                                    : "Enable Ghost Writer to get AI assistance while you edit" })), thinking && thinking.state === "thinking" && (_jsx("div", { className: "mt-2 text-blue-500", children: "Your Ghost Writer is thinking..." }))] })] })] }));
-}
-//# sourceMappingURL=GhostWriter.js.map