@saltcorn/copilot 0.8.0 → 0.8.2

package/actions/generate-tables.js

@@ -163,6 +163,13 @@ class GenerateTables {
             },
           },
         },
+        reused_table_names: {
+          type: "array",
+          items: { type: "string" },
+          description:
+            "Names of existing tables that are already complete and require no changes. " +
+            "List them here so the caller knows which tables were reused as-is. Do NOT repeat their field definitions in the tables array.",
+        },
       },
     };
   }
@@ -202,6 +209,12 @@ class GenerateTables {
     want to add or update. The system will automatically add new fields and update the settings of
     existing fields — it will not recreate or drop the table.
 
+    ## Reused tables
+
+    If an existing table is used by the application as-is (no new fields needed), do NOT repeat it
+    in the tables array. Instead, add its name to the reused_table_names array. This tells the
+    system to include it in the schema diagram without attempting to modify it.
+
     If a user requests creating a table with certain fields and the table already exists, automatically add any missing fields to that table. Do not ask the user for confirmation or prompt them again—just proceed with the table update.
 
     If a table has a ForeignKey field that references another table which does not yet exist in the
@@ -451,6 +464,7 @@ const buildMermaidMarkup = (tables) => {
 };
 
 module.exports = GenerateTables;
+module.exports.buildMermaidMarkup = buildMermaidMarkup;
 
 /* todo
 

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

@@ -52,20 +52,27 @@ class GeneratePageSkill {
   }
   get userActions() {
     return {
-      async build_copilot_page_gen({ user, name, title, description, html }) {
+      async build_copilot_page_gen({
+        user,
+        name,
+        title,
+        description,
+        html,
+        min_role = 100,
+      }) {
         const file = await File.from_contents(
           `${name}.html`,
           "text/html",
           html,
-          user.id,
-          100,
+          user?.id,
+          min_role
         );
 
         await Page.create({
           name,
           title,
           description,
-          min_role: 100,
+          min_role,
           layout: { html_file: file.path_to_serve },
         });
         setTimeout(() => getState().refresh_pages(), 200);
@@ -96,7 +103,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, 
@@ -114,12 +121,26 @@ class GeneratePageSkill {
 
  <script src="/static_assets/js/saltcorn-common.js"></script>
  <script src="/static_assets/js/saltcorn.js">
-`,
+`
         );
         const html = str.includes("```html")
           ? 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,
+            min_role: tool_call.input.min_role ?? 100,
+            html,
+          });
+          return {
+            stop: true,
+            add_response: `Page ${tool_call.input.name} created.`,
+          };
+        }
         return {
           stop: true,
           add_response: iframe({
@@ -127,15 +148,15 @@ 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",
             type: "button",
-            label: "Save page "+tool_call.input.name,
+            label: "Save page " + tool_call.input.name,
             input: { html },
           },
         };
@@ -150,7 +171,7 @@ class GeneratePageSkill {
           response.includes("Unable to provide HTML for this page")
         )
           return response;
-           if (
+        if (
           typeof response === "string" &&
           response.includes("The HTML code for the ")
         )
@@ -181,6 +202,12 @@ class GeneratePageSkill {
                 "A longer description that is not visible but appears in the page header and is indexed by search engines",
               type: "string",
             },
+            min_role: {
+              description:
+                "Minimum role required to access this page. Use 1 for admin-only, 40 for staff and above, 80 for logged-in users and above, 100 for public. Set this based on the intended audience described in the task.",
+              type: "integer",
+              enum: [1, 40, 80, 100],
+            },
             page_type: {
               description:
                 "The type of page to generate: a Marketing page if for promotional purposes, such as a landing page or a brouchure, with an appealing design. An Application page is simpler and an integrated part of the application",

package/agent-skills/registry-editor.js

@@ -6,6 +6,7 @@ const Field = require("@saltcorn/data/models/field");
 const User = require("@saltcorn/data/models/user");
 const Plugin = require("@saltcorn/data/models/plugin");
 const Role = require("@saltcorn/data/models/role");
+const File = require("@saltcorn/data/models/file");
 const WorkflowStep = require("@saltcorn/data/models/workflow_step");
 const { getState } = require("@saltcorn/data/db/state");
 
@@ -167,6 +168,7 @@ with both the entity type and name, and the new JSON definition as a string as a
                   "trigger",
                   "plugin",
                   "system-configuration-value",
+                  "file",
                   "type",
                 ],
               },
@@ -317,6 +319,11 @@ with both the entity type and name, and the new JSON definition as a string as a
               }
               return v;
             }
+            case "file": {
+              const file = await File.findOne({ filename: input.entity_name });
+              if (!file) return `file not found`;
+              return { filename: file.filename, min_role_read: file.min_role_read };
+            }
             case "plugin": {
               const plugin = await Plugin.findOne({ name: input.entity_name });
               if (!plugin) return `plugin not found`;
@@ -473,6 +480,7 @@ with both the entity type and name, and the new JSON definition as a string as a
                   "system-configuration-value",
                   "module-configuration",
                   "role",
+                  "file",
                 ],
               },
               entity_name: {
@@ -897,6 +905,13 @@ with both the entity type and name, and the new JSON definition as a string as a
                 await getState().refresh_roles();
                 return "Role created";
               }
+
+              case "file": {
+                const file = await File.findOne({ filename: input.entity_name });
+                if (!file) return `file not found: ${input.entity_name}`;
+                await file.set_role(entityValue.min_role_read);
+                return "Done";
+              }
             }
             return "Done";
           } catch (e) {

package/agent-skills/triggergen.js

@@ -0,0 +1,259 @@
+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.`
+    );
+  }
+
+  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;