@mydatavalue/polter 0.1.0 → 0.1.1

package/dist/index.js

@@ -437,6 +437,20 @@ async function executeAction(action, params, config) {
   return executeGuided(action, params, config);
 }
 var AgentActionContext = react.createContext(null);
+function definitionToRegisteredAction(def) {
+  return {
+    name: def.name,
+    description: def.description,
+    parameters: def.parameters,
+    onExecute: def.onExecute,
+    disabled: false,
+    disabledReason: void 0,
+    getExecutionTargets: () => [],
+    route: def.route,
+    navigateVia: def.navigateVia,
+    mountTimeout: def.mountTimeout
+  };
+}
 function AgentActionProvider({
   mode = "guided",
   stepDelay = 600,
@@ -446,24 +460,61 @@ function AgentActionProvider({
   cursorEnabled = true,
   children,
   onExecutionStart,
-  onExecutionComplete
+  onExecutionComplete,
+  registry,
+  navigate
 }) {
   const actionsRef = react.useRef(/* @__PURE__ */ new Map());
   const targetsRef = react.useRef(/* @__PURE__ */ new Map());
+  const registryRef = react.useRef(/* @__PURE__ */ new Map());
+  const navigateRef = react.useRef(navigate);
+  navigateRef.current = navigate;
   const [version, setVersion] = react.useState(0);
   const [isExecuting, setIsExecuting] = react.useState(false);
   const currentExecutionRef = react.useRef(null);
+  react.useEffect(() => {
+    const newNames = /* @__PURE__ */ new Set();
+    for (const def of registry ?? []) {
+      newNames.add(def.name);
+      const registryAction = definitionToRegisteredAction(def);
+      registryRef.current.set(def.name, registryAction);
+      const existing = actionsRef.current.get(def.name);
+      if (!existing || existing.getExecutionTargets().length === 0) {
+        actionsRef.current.set(def.name, registryAction);
+      }
+    }
+    for (const name of registryRef.current.keys()) {
+      if (!newNames.has(name)) {
+        registryRef.current.delete(name);
+        const current = actionsRef.current.get(name);
+        if (current && current.getExecutionTargets().length === 0) {
+          actionsRef.current.delete(name);
+        }
+      }
+    }
+    setVersion((v) => v + 1);
+  }, [registry]);
   const registerAction = react.useCallback((action) => {
     const existing = actionsRef.current.get(action.name);
+    const registryAction = registryRef.current.get(action.name);
+    if (registryAction) {
+      if (!action.route) action.route = registryAction.route;
+      if (!action.navigateVia) action.navigateVia = registryAction.navigateVia;
+      if (action.mountTimeout == null) action.mountTimeout = registryAction.mountTimeout;
+    }
     actionsRef.current.set(action.name, action);
     if (!existing || existing.description !== action.description || existing.disabled !== action.disabled || existing.disabledReason !== action.disabledReason) {
       setVersion((v) => v + 1);
     }
   }, []);
   const unregisterAction = react.useCallback((name) => {
-    if (actionsRef.current.delete(name)) {
-      setVersion((v) => v + 1);
+    const registryAction = registryRef.current.get(name);
+    if (registryAction) {
+      actionsRef.current.set(name, registryAction);
+    } else {
+      actionsRef.current.delete(name);
     }
+    setVersion((v) => v + 1);
   }, []);
   const registerTarget = react.useCallback((id, entry) => {
     targetsRef.current.set(id, entry);
@@ -508,12 +559,29 @@ function AgentActionProvider({
     },
     []
   );
+  const waitForActionMount = react.useCallback(
+    async (name, signal, timeout = 5e3) => {
+      const maxWait = timeout;
+      const pollInterval = 50;
+      const start = Date.now();
+      while (Date.now() - start < maxWait) {
+        if (signal?.aborted) return null;
+        const current = actionsRef.current.get(name);
+        if (current && current.getExecutionTargets().length > 0) {
+          return current;
+        }
+        await new Promise((r) => setTimeout(r, pollInterval));
+      }
+      return actionsRef.current.get(name) ?? null;
+    },
+    []
+  );
   const execute = react.useCallback(
     async (actionName, params) => {
       currentExecutionRef.current?.abort();
       const controller = new AbortController();
       currentExecutionRef.current = controller;
-      const action = actionsRef.current.get(actionName);
+      let action = actionsRef.current.get(actionName);
       if (!action) {
         return { success: false, actionName, error: `Action "${actionName}" not found` };
       }
@@ -527,7 +595,7 @@ function AgentActionProvider({
       setIsExecuting(true);
       onExecutionStart?.(actionName);
       try {
-        const result = await executeAction(action, params ?? {}, {
+        const executorConfig = {
           mode,
           stepDelay,
           overlayOpacity,
@@ -537,7 +605,59 @@ function AgentActionProvider({
           signal: controller.signal,
           resolveTarget,
           resolveNamedTarget
-        });
+        };
+        if (action.navigateVia && action.navigateVia.length > 0) {
+          for (const viaName of action.navigateVia) {
+            if (controller.signal.aborted) break;
+            const viaRegistered = actionsRef.current.get(viaName);
+            const viaTimeout = viaRegistered?.mountTimeout ?? 1e4;
+            const viaAction = await waitForActionMount(viaName, controller.signal, viaTimeout);
+            if (!viaAction || viaAction.getExecutionTargets().length === 0) {
+              return {
+                success: false,
+                actionName,
+                error: `Navigation chain action "${viaName}" not found or has no targets`
+              };
+            }
+            const viaResult = await executeAction(viaAction, {}, executorConfig);
+            if (!viaResult.success) {
+              return {
+                success: false,
+                actionName,
+                error: `Navigation chain failed at "${viaName}": ${viaResult.error}`
+              };
+            }
+          }
+          const mounted = await waitForActionMount(actionName, controller.signal, action.mountTimeout ?? 1e4);
+          if (!mounted || mounted.getExecutionTargets().length === 0) {
+            return {
+              success: false,
+              actionName,
+              error: `Action "${actionName}" did not mount after navigation chain \u2014 the page may require authentication or failed to load`
+            };
+          }
+          action = mounted;
+        } else {
+          const targets = action.getExecutionTargets();
+          if (targets.length === 0 && action.route && navigateRef.current) {
+            const path = action.route(params ?? {});
+            await navigateRef.current(path);
+            const mounted = await waitForActionMount(actionName, controller.signal, action.mountTimeout);
+            if (mounted) {
+              action = mounted;
+            }
+          }
+        }
+        if (action.disabled) {
+          const result2 = {
+            success: false,
+            actionName,
+            error: action.disabledReason || "Action is disabled"
+          };
+          onExecutionComplete?.(result2);
+          return result2;
+        }
+        const result = await executeAction(action, params ?? {}, executorConfig);
         onExecutionComplete?.(result);
         return result;
       } catch (err) {
@@ -555,7 +675,7 @@ function AgentActionProvider({
         }
       }
     },
-    [mode, stepDelay, overlayOpacity, spotlightPadding, tooltipEnabled, cursorEnabled, onExecutionStart, onExecutionComplete, resolveTarget, resolveNamedTarget]
+    [mode, stepDelay, overlayOpacity, spotlightPadding, tooltipEnabled, cursorEnabled, onExecutionStart, onExecutionComplete, resolveTarget, resolveNamedTarget, waitForActionMount]
   );
   const availableActions = react.useMemo(
     () => Array.from(actionsRef.current.values()).map((a) => ({
@@ -600,19 +720,24 @@ function AgentActionProvider({
   return /* @__PURE__ */ jsxRuntime.jsx(AgentActionContext.Provider, { value: contextValue, children });
 }
 var AgentStepContext = react.createContext(null);
-function AgentAction({
-  name,
-  description,
-  parameters,
-  onExecute,
-  disabled = false,
-  disabledReason,
-  children
-}) {
+function AgentAction(props) {
+  const {
+    action,
+    onExecute,
+    disabled = false,
+    disabledReason,
+    children
+  } = props;
+  const name = props.name ?? action?.name;
+  const description = props.description ?? action?.description ?? "";
+  const parameters = props.parameters ?? action?.parameters;
   const context = react.useContext(AgentActionContext);
   if (!context) {
     throw new Error("AgentAction must be used within an AgentActionProvider");
   }
+  if (!name) {
+    throw new Error('AgentAction requires either a "name" prop or an "action" prop');
+  }
   const wrapperRef = react.useRef(null);
   const stepsRef = react.useRef(/* @__PURE__ */ new Map());
   const onExecuteRef = react.useRef(onExecute);
@@ -1251,20 +1376,34 @@ function useAgentCommandRouter(fallback, getActionName) {
       const actionName = getActionName(command);
       const isRegistered = availableActions.some((a) => a.name === actionName && !a.disabled);
       if (isRegistered) {
-        await execute(actionName, command);
-        return;
+        return await execute(actionName, command);
       }
       await fallback?.(command);
+      return void 0;
     },
     [execute, availableActions, fallback, getActionName]
   );
 }
 
+// src/core/defineAction.ts
+function defineAction(config) {
+  return {
+    name: config.name,
+    description: config.description,
+    parameters: config.parameters,
+    route: config.route,
+    onExecute: config.onExecute,
+    navigateVia: config.navigateVia,
+    mountTimeout: config.mountTimeout
+  };
+}
+
 exports.AgentAction = AgentAction;
 exports.AgentActionProvider = AgentActionProvider;
 exports.AgentDevTools = AgentDevTools;
 exports.AgentStep = AgentStep;
 exports.AgentTarget = AgentTarget;
+exports.defineAction = defineAction;
 exports.generateToolSchemas = generateToolSchemas;
 exports.useAgentAction = useAgentAction;
 exports.useAgentActions = useAgentActions;