@saltcorn/copilot 0.7.5 → 0.8.0

package/agent-skills/database-design.js

@@ -39,7 +39,7 @@ const summarizeTables = (tables) =>
       })
       .join(", ");
     const ellipsis = table.fields.length > fields.length ? "..." : "";
-    return `${idx + 1}. ${table.table_name || "(missing name)"} – ${
+    return `${idx + 1}. ${table.table_name || "(missing name)"} \u2013 ${
       table.fields.length
     } field(s)${fieldSummary ? ` (${fieldSummary}${ellipsis})` : ""}`;
   });
@@ -96,12 +96,14 @@ const partitionTablesByExistence = async (tables = []) => {
   const newTables = [];
   const skippedExisting = [];
   const skippedDuplicates = [];
+  const existingTablesData = [];
   tables.forEach((table) => {
     const tableName =
       typeof table?.table_name === "string" ? table.table_name.trim() : "";
     const normalized = tableName.toLowerCase();
     if (tableName && existingNames.has(normalized)) {
       skippedExisting.push(tableName);
+      existingTablesData.push(table);
       return;
     }
     if (tableName && seenNewNames.has(normalized)) {
@@ -111,7 +113,7 @@ const partitionTablesByExistence = async (tables = []) => {
     if (tableName) seenNewNames.add(normalized);
     newTables.push(table);
   });
-  return { newTables, skippedExisting, skippedDuplicates };
+  return { newTables, skippedExisting, skippedDuplicates, existingTablesData };
 };
 
 const partitionTablesByValidity = (tables = []) => {
@@ -136,6 +138,34 @@ const partitionTablesByValidity = (tables = []) => {
   return { validTables, skippedMissingNames, skippedMissingFields };
 };
 
+const renderExistingTablesPreview = (existingTablesData) => {
+  if (!existingTablesData.length) return "";
+  return existingTablesData
+    .map((table) => {
+      const rows = (table.fields || [])
+        .filter((f) => (f?.name || "").toLowerCase() !== "id")
+        .map((f) => {
+          const cfg = f.type_and_configuration || {};
+          const typeParts = [
+            cfg.data_type === "ForeignKey"
+              ? `ForeignKey \u2192 ${cfg.reference_table || "?"}`
+              : cfg.data_type || "Unknown",
+          ];
+          if (f.calculated) typeParts.push(f.stored ? "stored calc" : "calc");
+          return `<tr><td>${f.name || ""}</td><td>${f.label || ""}</td><td>${typeParts.join(" ")}</td><td>${f.expression || ""}</td></tr>`;
+        })
+        .join("");
+      return (
+        `<div class="mt-3"><b>Add / update fields on existing table: ` +
+        `<code>${table.table_name}</code></b>` +
+        `<table class="table table-sm mt-1"><thead><tr>` +
+        `<th>Name</th><th>Label</th><th>Type</th><th>Expression</th></tr></thead>` +
+        `<tbody>${rows}</tbody></table></div>`
+      );
+    })
+    .join("");
+};
+
 const payloadFromToolCall = (tool_call) => {
   if (!tool_call) return { tables: [] };
   if (tool_call.input) return normalizeTablesPayload(tool_call.input);
@@ -161,67 +191,64 @@ class GenerateTablesSkill {
 
   get userActions() {
     return {
-      async apply_copilot_tables({ user, tables }) {
-        if (!tables?.length) return { notify: "Nothing to create." };
-        const { newTables, skippedExisting, skippedDuplicates } =
-          await partitionTablesByExistence(tables);
-        const { validTables, skippedMissingNames, skippedMissingFields } =
-          partitionTablesByValidity(newTables);
-        if (!validTables.length) {
-          const skippedMessages = [];
-          if (skippedExisting.length)
-            skippedMessages.push(
-              `Existing tables: ${skippedExisting.join(", ")}`,
+      async apply_copilot_tables({ user, tables, existing_tables }) {
+        const notifyParts = [];
+
+        // Create brand-new tables
+        if (tables?.length) {
+          const { newTables, skippedDuplicates } =
+            await partitionTablesByExistence(tables);
+          const { validTables, skippedMissingNames, skippedMissingFields } =
+            partitionTablesByValidity(newTables);
+          if (validTables.length) {
+            await GenerateTables.execute({ tables: validTables }, { user });
+            notifyParts.push(
+              `Created tables: ${validTables.map((t) => t.table_name).join(", ")}`,
             );
+          }
           if (skippedDuplicates.length)
-            skippedMessages.push(
-              `Duplicate definitions: ${skippedDuplicates.join(", ")}`,
+            notifyParts.push(
+              `Ignored duplicate definitions: ${skippedDuplicates.join(", ")}`,
             );
           if (skippedMissingNames.length)
-            skippedMessages.push(
+            notifyParts.push(
               `Missing table_name: ${skippedMissingNames.join(", ")}`,
             );
           if (skippedMissingFields.length)
-            skippedMessages.push(
+            notifyParts.push(
               `Tables without fields: ${skippedMissingFields.join(", ")}`,
             );
-          return {
-            notify:
-              skippedMessages.length > 0
-                ? `Nothing to create. Skipped ${skippedMessages.join("; ")}.`
-                : "Nothing to create.",
-          };
         }
-        await GenerateTables.execute({ tables: validTables }, { user });
-        const createdNames = validTables.map((t) => t.table_name).join(", ");
-        const skippedMessages = [];
-        if (skippedExisting.length)
-          skippedMessages.push(
-            `Skipped existing tables: ${skippedExisting.join(", ")}`,
-          );
-        if (skippedDuplicates.length)
-          skippedMessages.push(
-            `Ignored duplicate definitions: ${skippedDuplicates.join(", ")}`,
-          );
-        if (skippedMissingNames.length)
-          skippedMessages.push(
-            `Missing table_name: ${skippedMissingNames.join(", ")}`,
-          );
-        if (skippedMissingFields.length)
-          skippedMessages.push(
-            `Tables without fields: ${skippedMissingFields.join(", ")}`,
-          );
+
+        // Add/update fields on existing tables
+        if (existing_tables?.length) {
+          for (const table of existing_tables) {
+            if (!table?.table_name || !Array.isArray(table.fields)) continue;
+            const { added, updated } =
+              await GenerateTables.execute_add_or_update_fields(
+                { table_name: table.table_name, fields: table.fields },
+                { user },
+              );
+            const parts = [];
+            if (added.length) parts.push(`added: ${added.join(", ")}`);
+            if (updated.length) parts.push(`updated: ${updated.join(", ")}`);
+            if (parts.length)
+              notifyParts.push(
+                `${table.table_name} \u2014 ${parts.join("; ")}`,
+              );
+          }
+        }
+
         return {
-          notify: [`Created tables: ${createdNames}`, ...skippedMessages].join(
-            ". ",
-          ),
+          notify: notifyParts.length
+            ? notifyParts.join(". ")
+            : "Nothing to apply.",
         };
       },
     };
   }
 
   provideTools = () => {
-    const parameters = GenerateTables.json_schema();
     return {
       type: "function",
       process: async (input) => {
@@ -230,24 +257,28 @@ class GenerateTablesSkill {
         if (!tables.length) {
           return "No tables were provided for generate_tables.";
         }
-        const { newTables, skippedExisting, skippedDuplicates } =
-          await partitionTablesByExistence(tables);
+        const {
+          newTables,
+          skippedExisting,
+          skippedDuplicates,
+          existingTablesData,
+        } = await partitionTablesByExistence(tables);
         const { validTables, skippedMissingNames, skippedMissingFields } =
           partitionTablesByValidity(newTables);
         const summaryLines = validTables.length
           ? summarizeTables(validTables).map((line) => `- ${line}`)
           : [];
-        const warnings = collectTableWarnings(tables);
-        if (skippedExisting.length)
-          skippedExisting.forEach((name) =>
-            warnings.push(
-              `Table "${name}" already exists and will not be recreated by generate_tables.`,
-            ),
-          );
+        const existingSummaryLines = existingTablesData.map(
+          (t) =>
+            `- "${t.table_name}" (exists) \u2014 ${(t.fields || []).length} field(s) will be added/updated`,
+        );
+        const warnings = collectTableWarnings(
+          tables.filter((t) => !skippedExisting.includes(t.table_name)),
+        );
         if (skippedDuplicates.length)
           skippedDuplicates.forEach((name) =>
             warnings.push(
-              `Table "${name}" was defined multiple times in this request; only the first definition will be used.`,
+              `Table "${name}" was defined multiple times; only the first definition will be used.`,
             ),
           );
         skippedMissingNames.forEach((label) =>
@@ -263,26 +294,31 @@ class GenerateTablesSkill {
         const warningLines = warnings.length
           ? ["Warnings:", ...warnings.map((w) => `- ${w}`)]
           : [];
-        const summarySection = summaryLines.length
+        const newSection = summaryLines.length
           ? [
-              `Ready to create ${validTables.length} new table${
-                validTables.length === 1 ? "" : "s"
-              }:`,
+              `Ready to create ${validTables.length} new table${validTables.length === 1 ? "" : "s"}:`,
               ...summaryLines,
             ]
-          : [
-              "No new tables remain after removing existing, duplicate, or invalid table definitions.",
-            ];
+          : [];
+        const existingSection = existingSummaryLines.length
+          ? [
+              "Existing tables (fields will be added/updated):",
+              ...existingSummaryLines,
+            ]
+          : [];
+        const nothingToDo = !newSection.length && !existingSection.length;
         return [
           `Received ${tables.length} table definition${tables.length === 1 ? "" : "s"}.`,
-          ...summarySection,
+          ...(nothingToDo
+            ? ["Nothing to do after filtering."]
+            : [...newSection, ...existingSection]),
           ...warningLines,
         ].join("\n");
       },
-      postProcess: async ({ tool_call }) => {
+      postProcess: async ({ tool_call, req }) => {
         const payload = payloadFromToolCall(tool_call);
         const tables = payload.tables || [];
-        const { newTables, skippedExisting, skippedDuplicates } =
+        const { newTables, skippedDuplicates, existingTablesData } =
           await partitionTablesByExistence(tables);
         const { validTables, skippedMissingNames, skippedMissingFields } =
           partitionTablesByValidity(newTables);
@@ -290,22 +326,16 @@ class GenerateTablesSkill {
         try {
           if (validTables.length) {
             preview = GenerateTables.render_html({ tables: validTables });
-          } else {
-            preview =
-              '<div class="alert alert-info">No new tables to preview because every provided table already exists or was invalid.</div>';
           }
         } catch (e) {
-          console.log("We are in postProcess but rendering failed", {
+          console.log("generate_tables postProcess render failed", {
             e,
             time: new Date(),
           });
           preview = `<pre>${JSON.stringify(payload, null, 2)}</pre>`;
         }
+        const existingPreview = renderExistingTablesPreview(existingTablesData);
         const warningChunks = [];
-        if (skippedExisting.length)
-          warningChunks.push(
-            `Skipped existing tables: ${skippedExisting.join(", ")}`,
-          );
         if (skippedDuplicates.length)
           warningChunks.push(
             `Ignored duplicate definitions: ${skippedDuplicates.join(", ")}`,
@@ -321,26 +351,48 @@ class GenerateTablesSkill {
         const warningHtml = warningChunks.length
           ? `<div class="alert alert-warning">${warningChunks.join("<br/>")}</div>`
           : "";
+
+        if (this.yoloMode) {
+          this.userActions.apply_copilot_tables({
+            user: req?.user,
+            tables: validTables,
+          });
+          return { stop: true, add_response: `${warningHtml}${preview}` };
+        }
+
+        const hasAnything =
+          validTables.length > 0 || existingTablesData.length > 0;
+        const labelParts = [];
+        if (validTables.length)
+          labelParts.push(
+            `Create ${validTables.map((t) => t.table_name).join(", ")}`,
+          );
+        if (existingTablesData.length)
+          labelParts.push(
+            `Update fields on ${existingTablesData
+              .map((t) => t.table_name)
+              .join(", ")}`,
+          );
         return {
           stop: true,
-          add_response: `${warningHtml}${preview}`,
-          add_user_action:
-            validTables.length > 0
-              ? {
-                  name: "apply_copilot_tables",
-                  type: "button",
-                  label: `Create tables (${validTables
-                    .map((t) => t.table_name)
-                    .join(", ")})`,
-                  input: { tables: validTables },
-                }
-              : undefined,
+          add_response: `${warningHtml}${preview}${existingPreview}`,
+          add_user_action: hasAnything
+            ? {
+                name: "apply_copilot_tables",
+                type: "button",
+                label: labelParts.join(" + "),
+                input: {
+                  tables: validTables,
+                  existing_tables: existingTablesData,
+                },
+              }
+            : undefined,
         };
       },
       function: {
         name: GenerateTables.function_name,
         description: GenerateTables.description,
-        parameters,
+        parameters: GenerateTables.json_schema(),
       },
     };
   };

package/agent-skills/install-plugin.js

@@ -0,0 +1,111 @@
+const InstallPluginAction = require("../actions/install-plugin-action");
+const Plugin = require("@saltcorn/data/models/plugin");
+
+class InstallPluginSkill {
+  static skill_name = "Install Plugin";
+
+  get skill_label() {
+    return "Install Plugin";
+  }
+
+  constructor(cfg) {
+    Object.assign(this, cfg);
+  }
+
+  async systemPrompt() {
+    return (
+      `Use list_plugins to browse available Saltcorn store plugins before installing. ` +
+      `Use install_plugin to install a plugin. Prefer store plugins (plugin_name) over npm packages. ` +
+      `Do not install a plugin that is already installed.`
+    );
+  }
+
+  get userActions() {
+    return {
+      async install_copilot_plugin(input, req) {
+        const result = await InstallPluginAction.execute(input, req);
+        return {
+          notify: result.postExec || "Plugin installation complete.",
+        };
+      },
+    };
+  }
+
+  provideTools = () => {
+    return [
+      {
+        type: "function",
+        process: async ({ category }) => {
+          try {
+            const plugins = await Plugin.store_plugins_available();
+            const filtered =
+              category === "theme"
+                ? plugins.filter((p) => p.has_theme)
+                : category === "auth"
+                  ? plugins.filter((p) => p.has_auth)
+                  : plugins;
+            if (!filtered.length) return "No plugins found.";
+            return filtered
+              .map(
+                (p) => `${p.name}${p.description ? `: ${p.description}` : ""}`,
+              )
+              .join("\n");
+          } catch (e) {
+            return `Error listing plugins: ${e.message}`;
+          }
+        },
+        function: {
+          name: "list_plugins",
+          description:
+            "List available plugins from the Saltcorn store. Call this before installing to find the right plugin name.",
+          parameters: {
+            type: "object",
+            properties: {
+              category: {
+                type: "string",
+                enum: ["theme", "auth", "all"],
+                description:
+                  "Filter plugins: 'theme' for UI themes, 'auth' for authentication plugins, 'all' for everything",
+              },
+            },
+            required: ["category"],
+          },
+        },
+      },
+      {
+        type: "function",
+        process: async (input) => {
+          const label = input.plugin_name || input.npm_package;
+          if (!label) return "Please provide a plugin name or npm package.";
+          return `Installing plugin: ${label}...`;
+        },
+        postProcess: async ({ tool_call, req }) => {
+          const input = tool_call.input || {};
+          if (this.yoloMode) {
+            const result = await InstallPluginAction.execute(input, req);
+            return {
+              stop: true,
+              add_response: result.postExec || "Plugin installation complete.",
+            };
+          }
+          return {
+            stop: true,
+            add_user_action: {
+              name: "install_copilot_plugin",
+              type: "button",
+              label: `Install plugin ${input.plugin_name || input.npm_package}`,
+              input,
+            },
+          };
+        },
+        function: {
+          name: InstallPluginAction.function_name,
+          description: InstallPluginAction.description,
+          parameters: InstallPluginAction.json_schema(),
+        },
+      },
+    ];
+  };
+}
+
+module.exports = InstallPluginSkill;

package/agent-skills/js-action.js

@@ -0,0 +1,183 @@
+const GenerateJsAction = require("../actions/generate-js-action");
+const { getPromptFromTemplate } = require("../common");
+
+class GenerateJsActionSkill {
+  static skill_name = "Javascript Action";
+
+  get skill_label() {
+    return "Javascript Action";
+  }
+
+  constructor(cfg) {
+    Object.assign(this, cfg);
+  }
+
+  get userActions() {
+    return {
+      async build_copilot_js_action(input) {
+        const name = input.name;
+        const code = input.code;
+        const description = input.description;
+        const when_trigger = input.when_trigger;
+        const trigger_table = input.trigger_table;
+        const user = input.user;
+        if (!name || !code) {
+          return {
+            notify:
+              "Both name and code are required to generate a Javascript action.",
+          };
+        }
+        const result = await GenerateJsAction.execute(
+          {
+            action_javascript_code: code,
+            action_name: name,
+            action_description: description,
+            when_trigger,
+            trigger_table,
+          },
+          { user },
+        );
+        return {
+          notify: result?.postExec || `Javascript action saved: ${name}`,
+          name,
+          code,
+          description,
+        };
+      },
+    };
+  }
+
+  provideTools = () => {
+    return {
+      type: "function",
+      process: async (input) => {
+        const name = input.name;
+        const description = input.description;
+        if (!name) {
+          return "A name is required to generate a Javascript action.";
+        }
+        return [
+          `Generating Javascript action: ${name}.`,
+          description ? `Description: ${description}` : null,
+        ]
+          .filter(Boolean)
+          .join("\n");
+      },
+      postProcess: async ({ tool_call, generate }) => {
+        const input = tool_call.input || {};
+        const name = input.name;
+        const description = input.description;
+        const when_trigger = input.when_trigger;
+        const trigger_table = input.trigger_table;
+        if (!name) {
+          return {
+            stop: true,
+            add_response: "Cannot create Javascript action: name is required.",
+          };
+        }
+
+        const partPrompt = await getPromptFromTemplate(
+          "action-builder.txt",
+          "",
+        );
+        const contextParts = [
+          description ? `Action description: ${description}` : null,
+          when_trigger ? `Trigger: ${when_trigger}` : null,
+          trigger_table ? `Table: ${trigger_table}` : null,
+        ].filter(Boolean);
+
+        const prompt = [
+          partPrompt,
+          contextParts.length ? contextParts.join("\n") : null,
+          `Generate the JavaScript code for the action named "${name}" by calling the generate_js_code tool.`,
+        ]
+          .filter(Boolean)
+          .join("\n\n");
+
+        const answer = await generate(prompt, {
+          tools: [
+            {
+              type: "function",
+              function: {
+                name: "generate_js_code",
+                description: "Provide the JavaScript code for the action",
+                parameters: {
+                  type: "object",
+                  required: ["code"],
+                  properties: {
+                    code: {
+                      type: "string",
+                      description: "JavaScript code for the action",
+                    },
+                  },
+                },
+              },
+            },
+          ],
+          tool_choice: {
+            type: "function",
+            function: { name: "generate_js_code" },
+          },
+        });
+
+        const tc = answer.getToolCalls()[0];
+        const code = tc?.input?.code;
+
+        if (!code) {
+          return {
+            stop: true,
+            add_response: "Failed to generate JavaScript code for the action.",
+          };
+        }
+
+        return {
+          stop: true,
+          add_response: GenerateJsAction.render_html({
+            action_javascript_code: code,
+            action_name: name,
+            action_description: description,
+            when_trigger,
+            trigger_table,
+          }),
+          add_user_action: {
+            name: "build_copilot_js_action",
+            type: "button",
+            label: `Save Javascript action (${name})`,
+            input: { name, code, description, when_trigger, trigger_table },
+          },
+        };
+      },
+      function: {
+        name: GenerateJsAction.function_name,
+        description: GenerateJsAction.description,
+        parameters: {
+          type: "object",
+          required: ["name"],
+          properties: {
+            name: {
+              type: "string",
+              description: "Name of the Javascript action.",
+            },
+            description: {
+              type: "string",
+              description: "Description of the action.",
+            },
+            when_trigger: {
+              type: "string",
+              enum: ["Insert", "Update", "Delete", "Daily", "Hourly", "Weekly"],
+              description:
+                "The event that fires this action. Only set if the user explicitly wants this trigger to run on a table row event or schedule. Leave unset if the user has not specified when it should run.",
+            },
+            trigger_table: {
+              type: "string",
+              description:
+                "The table whose row events (Insert/Update/Delete) should fire this action. Only set if the user explicitly says this action should be triggered by changes to that table. Do NOT set just because the code reads data from a table.",
+            },
+          },
+        },
+      },
+    };
+  };
+}
+
+module.exports = GenerateJsActionSkill;