@saltcorn/copilot 0.8.0 → 0.8.1

package/actions/generate-trigger.js

@@ -0,0 +1,61 @@
+const Trigger = require("@saltcorn/data/models/trigger");
+const Table = require("@saltcorn/data/models/table");
+const { a, div, pre } = require("@saltcorn/markup/tags");
+
+class GenerateTrigger {
+  static title = "Generate Trigger";
+  static function_name = "generate_trigger";
+  static description =
+    "Generate a Saltcorn trigger with any available action type";
+
+  static render_html({
+    action_name,
+    action_type,
+    when_trigger,
+    trigger_table,
+    action_config,
+  }) {
+    const summary =
+      `<strong>${action_name}</strong> — ${action_type}` +
+      (when_trigger ? `: ${when_trigger}` : "") +
+      (trigger_table ? ` on ${trigger_table}` : "");
+    const configSection =
+      action_config && Object.keys(action_config).length
+        ? pre({ class: "mt-2" }, JSON.stringify(action_config, null, 2))
+        : "";
+    return div({ class: "mb-3" }, summary) + configSection;
+  }
+
+  static async execute(
+    { action_name, action_type, when_trigger, trigger_table, action_config },
+    req,
+  ) {
+    let table_id;
+    if (trigger_table) {
+      const table = Table.findOne({ name: trigger_table });
+      if (!table) return { postExec: `Table not found: ${trigger_table}` };
+      table_id = table.id;
+    }
+    const trigger = await Trigger.create({
+      name: action_name,
+      when_trigger: when_trigger || "Never",
+      table_id,
+      action: action_type,
+      configuration: action_config || {},
+    });
+    Trigger.emitEvent("AppChange", `Trigger ${trigger.name}`, req?.user, {
+      entity_type: "Trigger",
+      entity_name: trigger.name,
+    });
+    return {
+      postExec:
+        "Trigger created. " +
+        a(
+          { target: "_blank", href: `/actions/configure/${trigger.id}` },
+          "Configure trigger.",
+        ),
+    };
+  }
+}
+
+module.exports = GenerateTrigger;

package/actions/generate-workflow.js

@@ -215,7 +215,8 @@ class GenerateWorkflow {
         workflow_steps: await steps(),
         workflow_name: {
           description:
-            "The name of the workflow. Can include spaces and mixed case, should be 1-5 words.",
+            "The name of the workflow. Can include spaces and mixed case, should be 1-5 words. " +
+            "Must be unique across all workflows. When creating variants for different events on the same table (e.g. insert, update, delete), include the event in each name — e.g. 'Recalc trip packing insert', 'Recalc trip packing update'.",
           type: "string",
         },
         when_trigger: {
@@ -254,6 +255,10 @@ class GenerateWorkflow {
     return `Use the generate_workflow tool to construct computational workflows according to specifications. You must create
   the workflow by calling the generate_workflow tool, with the step required to implement the specification.
 
+  **Trigger vs workflow:** If the task can be completed in a single step (e.g. updating one field with modify_row, sending a single notification), use the generate_trigger tool instead — a workflow is only appropriate when multiple steps, branching, or looping are required. If the task requires several independent single-step actions (e.g. "mark complete" and "mark incomplete"), create a separate trigger for each — do NOT bundle them into one workflow.
+
+  **Naming:** Workflow names must be unique. When creating variants for different events on the same table (e.g. insert, update, delete), include the event in each name — e.g. "Recalc trip packing insert", "Recalc trip packing update", "Recalc trip packing delete".
+
   ${contextBlocks}
 
   The steps are specified as JSON objects. Each step has a name, specified in the step_name key in the JSON object.

package/agent-skills/pagegen.js

@@ -57,7 +57,7 @@ class GeneratePageSkill {
           `${name}.html`,
           "text/html",
           html,
-          user.id,
+          user?.id,
           100,
         );
 
@@ -96,7 +96,7 @@ class GeneratePageSkill {
           );
         } else return "Metadata recieved";
       },
-      postProcess: async ({ tool_call, generate }) => {
+      postProcess: async ({ tool_call, generate, req }) => {
         const str = await generate(
           `Now generate the contents of the ${tool_call.input.name} HTML page. If I asked you to embed a view, 
  use the <embed-view> self-closing tag to do so, setting the view name in the viewname attribute. For example, 
@@ -120,6 +120,19 @@ class GeneratePageSkill {
           ? str.split("```html")[1].split("```")[0]
           : str;
 
+        if (this.yoloMode) {
+          await this.userActions.build_copilot_page_gen({
+            user: req?.user,
+            name: tool_call.input.name,
+            title: tool_call.input.title,
+            description: tool_call.input.description,
+            html,
+          });
+          return {
+            stop: true,
+            add_response: `Page ${tool_call.input.name} created.`,
+          };
+        }
         return {
           stop: true,
           add_response: iframe({
@@ -127,10 +140,10 @@ class GeneratePageSkill {
             width: 500,
             height: 800,
           }),
-          add_system_prompt: `If the user asks you to regenerate the page, 
-          you must run the generate_page tool again. After running this tool 
-          you will be prompted to generate the html again. You should repeat 
-          the html from the previous answer except for the changes the user 
+          add_system_prompt: `If the user asks you to regenerate the page,
+          you must run the generate_page tool again. After running this tool
+          you will be prompted to generate the html again. You should repeat
+          the html from the previous answer except for the changes the user
           is requesting.`,
           add_user_action: {
             name: "build_copilot_page_gen",

package/agent-skills/triggergen.js

@@ -0,0 +1,263 @@
+const Trigger = require("@saltcorn/data/models/trigger");
+const Table = require("@saltcorn/data/models/table");
+const { getState } = require("@saltcorn/data/db/state");
+const { getActionConfigFields } = require("@saltcorn/data/plugin-helper");
+const { fieldProperties } = require("../common");
+const GenerateAnyAction = require("../actions/generate-trigger");
+
+const flattenOptionGroups = (options = []) =>
+  options.flatMap((opt) =>
+    opt?.optgroup && Array.isArray(opt.options) ? opt.options : [opt],
+  );
+
+class AnyActionSkill {
+  static skill_name = "Generate trigger";
+
+  get skill_label() {
+    return "Generate trigger";
+  }
+
+  constructor(cfg) {
+    Object.assign(this, cfg);
+  }
+
+  async systemPrompt() {
+    return (
+      `If the user asks to create an action or trigger, use the generate_trigger tool. ` +
+      `Pick the most appropriate action_type from the available options. ` +
+      `Only set when_trigger and trigger_table if the user has specified them. ` +
+      `Trigger names must be unique — when creating variants for different events on the same table, include the event in each name (e.g. "Recalc trip packing insert", "Recalc trip packing update", "Recalc trip packing delete").\n\n` +
+      `**Trigger vs workflow:** Use a trigger (this tool) when the action is a single step — ` +
+      `for example, setting a field value with modify_row, sending a notification, or calling an API. ` +
+      `Only use a workflow when the logic requires multiple steps, branching, or looping. ` +
+      `If the task requires several independent single-step actions (e.g. "mark complete" and "mark incomplete"), call this tool once per action — do NOT bundle them into one workflow.\n\n` +
+      `**Navigation is a view concern:** If a task description says "return the user to X" or "navigate back", ` +
+      `do NOT add a navigation step inside the trigger. Triggers only handle data operations. ` +
+      `Navigation (GoBack) is configured on the button in the list view, not inside the trigger itself.\n\n` +
+      `**Verification/confirmation emails after user registration:** Create a trigger with event "Insert" on the "users" table, ` +
+      `action_type "run_js_code". Do NOT use the send_email action — it will not work for verification. ` +
+      `Set the action_config "code" field to exactly:\n` +
+      `const { send_verification_email } = require("@saltcorn/data/models/email");\nawait send_verification_email(row, req);`
+    );
+  }
+
+  get userActions() {
+    return {
+      async build_copilot_any_action(input) {
+        const {
+          name,
+          action_type,
+          when_trigger,
+          trigger_table,
+          action_config,
+          user,
+        } = input;
+        if (!name || !action_type) {
+          return { notify: "Action name and type are required." };
+        }
+        const result = await GenerateAnyAction.execute(
+          {
+            action_name: name,
+            action_type,
+            when_trigger,
+            trigger_table,
+            action_config,
+          },
+          { user },
+        );
+        return { notify: result?.postExec || `Action saved: ${name}` };
+      },
+    };
+  }
+
+  provideTools = () => {
+    const state = getState();
+    const allActionOptions = (() => {
+      try {
+        return (
+          Trigger.action_options({ notRequireRow: false, workflow: false }) ||
+          []
+        );
+      } catch (_) {
+        return [];
+      }
+    })();
+    const stateActions = state?.actions || {};
+    const stateActionNames = Object.keys(stateActions);
+    const catalogNames = flattenOptionGroups(allActionOptions);
+    const actionEnum = Array.from(
+      new Set([...catalogNames, ...stateActionNames]),
+    ).sort();
+
+    const tables = (state.tables || []).map((t) => t.name);
+
+    return {
+      type: "function",
+      function: {
+        name: GenerateAnyAction.function_name,
+        description: GenerateAnyAction.description,
+        parameters: {
+          type: "object",
+          required: ["name", "action_type"],
+          properties: {
+            name: {
+              type: "string",
+              description:
+                "A human-readable name for the trigger/action (1–5 words). " +
+                "Must be unique across all triggers. When creating multiple triggers for different events on the same table (e.g. insert, update, delete), include the event in the name — e.g. 'Recalc trip packing insert', 'Recalc trip packing update'.",
+            },
+            action_type: {
+              type: "string",
+              enum: actionEnum.length ? actionEnum : undefined,
+              description: "The action to run when the trigger fires.",
+            },
+            when_trigger: {
+              type: "string",
+              enum: Trigger.when_options,
+              description:
+                "When to fire this trigger. Only set if the user has specified. Leave unset for manual/API-call triggers.",
+            },
+            trigger_table: {
+              type: "string",
+              enum: tables,
+              description:
+                "Table for row-level triggers (Insert/Update/Delete/Validate). Only set when when_trigger requires a table.",
+            },
+          },
+        },
+      },
+      process: async (input) => {
+        const { name, action_type, when_trigger, trigger_table } = input || {};
+        return [
+          `Generating ${action_type} action: ${name}.`,
+          when_trigger ? `Trigger: ${when_trigger}` : null,
+          trigger_table ? `Table: ${trigger_table}` : null,
+        ]
+          .filter(Boolean)
+          .join("\n");
+      },
+      postProcess: async ({ tool_call, generate }) => {
+        const { name, action_type, when_trigger, trigger_table } =
+          tool_call.input || {};
+        if (!name || !action_type) {
+          return {
+            stop: true,
+            add_response: "Action name and type are required.",
+          };
+        }
+
+        const stateAction = getState()?.actions?.[action_type];
+        let action_config = {};
+
+        if (stateAction) {
+          const table = trigger_table
+            ? Table.findOne({ name: trigger_table })
+            : null;
+          let cfgFields = [];
+          try {
+            cfgFields = await getActionConfigFields(stateAction, table, {
+              copilot: true,
+            });
+          } catch (_) {}
+
+          const configurable = cfgFields.filter(
+            (f) => f.input_type !== "section_header",
+          );
+          if (configurable.length > 0) {
+            const properties = {};
+            for (const f of configurable) {
+              properties[f.name] = {
+                description: f.sublabel || f.label || f.name,
+                ...fieldProperties(f),
+              };
+              if (!properties[f.name].type) properties[f.name].type = "string";
+            }
+
+            let actionPrompt = "";
+            if (stateAction.copilot_generate_trigger_prompt) {
+              if (
+                typeof stateAction.copilot_generate_trigger_prompt === "string"
+              )
+                actionPrompt = stateAction.copilot_generate_trigger_prompt;
+              else if (
+                typeof stateAction.copilot_generate_trigger_prompt ===
+                "function"
+              )
+                actionPrompt =
+                  await stateAction.copilot_generate_trigger_prompt(
+                    tool_call.input,
+                  );
+            }
+
+            const llm = getState().functions.llm_generate;
+            const answer = await llm.run(
+              `${actionPrompt ? actionPrompt + "\n\n" : ""}Configure the "${action_type}" action named "${name}". ` +
+                `Fill in the configuration by calling the generate_action_config tool.`,
+              {
+                tools: [
+                  {
+                    type: "function",
+                    function: {
+                      name: "generate_action_config",
+                      description: `Provide configuration fields for the ${action_type} action`,
+                      parameters: { type: "object", properties },
+                    },
+                  },
+                ],
+                tool_choice: {
+                  type: "function",
+                  function: { name: "generate_action_config" },
+                },
+              },
+            );
+
+            const tc = answer.getToolCalls()[0];
+            if (tc?.input) action_config = tc.input;
+          }
+        }
+
+        if (this.yoloMode) {
+          const result = await GenerateAnyAction.execute(
+            {
+              action_name: name,
+              action_type,
+              when_trigger,
+              trigger_table,
+              action_config,
+            },
+            {},
+          );
+          return {
+            stop: true,
+            add_response: result?.postExec || `Action ${name} created.`,
+          };
+        }
+
+        return {
+          stop: true,
+          add_response: GenerateAnyAction.render_html({
+            action_name: name,
+            action_type,
+            when_trigger,
+            trigger_table,
+            action_config,
+          }),
+          add_user_action: {
+            name: "build_copilot_any_action",
+            type: "button",
+            label: `Save action (${name})`,
+            input: {
+              name,
+              action_type,
+              when_trigger,
+              trigger_table,
+              action_config,
+            },
+          },
+        };
+      },
+    };
+  };
+}
+
+module.exports = AnyActionSkill;