@saltcorn/copilot 0.7.4 → 0.8.0

package/agent-skills/viewgen.js

@@ -1,6 +1,7 @@
 const Table = require("@saltcorn/data/models/table");
 const View = require("@saltcorn/data/models/view");
 const { fieldProperties } = require("../common");
+const { initial_config_all_fields } = require("@saltcorn/data/plugin-helper");
 const { getState } = require("@saltcorn/data/db/state");
 const {
   div,
@@ -12,6 +13,91 @@ const {
   iframe,
   text_attr,
 } = require("@saltcorn/markup/tags");
+const builderGen = require("../builder-gen");
+
+const collectLayoutFieldNames = (segment, out = new Set()) => {
+  if (!segment || typeof segment !== "object") return out;
+  if (Array.isArray(segment)) {
+    segment.forEach((s) => collectLayoutFieldNames(s, out));
+    return out;
+  }
+  if (segment.type === "field" && segment.field_name)
+    out.add(segment.field_name);
+  if (segment.above) collectLayoutFieldNames(segment.above, out);
+  if (segment.besides) collectLayoutFieldNames(segment.besides, out);
+  if (segment.contents) collectLayoutFieldNames(segment.contents, out);
+  if (Array.isArray(segment.tabs))
+    segment.tabs.forEach((t) => collectLayoutFieldNames(t?.contents, out));
+  return out;
+};
+
+const findFilterFieldSegment = (segment) => {
+  if (!segment || typeof segment !== "object") return null;
+  if (segment.type === "field") return segment;
+  if (segment.type === "dropdown_filter" || segment.type === "toggle_filter") {
+    return { field_name: segment.field_name, fieldview: "edit" };
+  }
+  if (Array.isArray(segment.above)) {
+    for (const item of segment.above) {
+      const found = findFilterFieldSegment(item);
+      if (found) return found;
+    }
+  }
+  if (Array.isArray(segment.besides)) {
+    for (const item of segment.besides) {
+      const found = findFilterFieldSegment(item);
+      if (found) return found;
+    }
+  }
+  if (segment.contents) {
+    if (Array.isArray(segment.contents)) {
+      for (const item of segment.contents) {
+        const found = findFilterFieldSegment(item);
+        if (found) return found;
+      }
+    } else {
+      const found = findFilterFieldSegment(segment.contents);
+      if (found) return found;
+    }
+  }
+  if (Array.isArray(segment.tabs)) {
+    for (const tab of segment.tabs) {
+      if (tab?.contents) {
+        const found = findFilterFieldSegment(tab.contents);
+        if (found) return found;
+      }
+    }
+  }
+  if (Array.isArray(segment.contents) && Array.isArray(segment.contents[0])) {
+    for (const row of segment.contents) {
+      if (Array.isArray(row)) {
+        for (const cell of row) {
+          const found = findFilterFieldSegment(cell);
+          if (found) return found;
+        }
+      }
+    }
+  }
+  return null;
+};
+
+const normalizeFilterField = (segment) => ({
+  type: "field",
+  field_name: segment.field_name,
+  fieldview: segment.fieldview || "edit",
+  textStyle: segment.textStyle || "",
+  block: segment.block ?? false,
+  configuration: segment.configuration || {},
+});
+
+const toFilterColumn = (segment) => ({
+  type: "Field",
+  field_name: segment.field_name,
+  fieldview: segment.fieldview || "edit",
+  textStyle: segment.textStyle || "",
+  block: segment.block ?? false,
+  configuration: segment.configuration || {},
+});
 
 class GenerateViewSkill {
   static skill_name = "Generate View";
@@ -25,8 +111,11 @@ class GenerateViewSkill {
   }
 
   async systemPrompt() {
-    return `If the user asks to generate a view, use the generate_view tool to enter 
-a view generation mode. The tool call only requires high-level details to start this sequence.`;
+    return (
+      `If the user asks to generate a view, use the generate_view tool to enter ` +
+      `a view generation mode. The tool call only requires high-level details to start this sequence.\n` +
+      `The Edit viewtemplate serves both create (no id in state) and edit (id in state) — one view covers both modes.`
+    );
   }
 
   get userActions() {
@@ -38,13 +127,20 @@ a view generation mode. The tool call only requires high-level details to start
         table,
         min_role,
       }) {
+        const normalizedRole = min_role || "public";
+        const tableRow = table ? Table.findOne({ name: table }) : null;
         await View.create({
           name,
           viewtemplate: viewpattern,
-          table: Table.findOne({ name: table }),
-          min_role: { admin: 1, public: 100, user: 80 }[min_role],
+          table_id: tableRow?.id,
+          table: tableRow,
+          min_role: { admin: 1, public: 100, user: 80 }[normalizedRole],
           configuration: wfctx,
         });
+        const vt = getState().viewtemplates[viewpattern];
+        if (vt?.copilot_post_create) {
+          await vt.copilot_post_create({ name, configuration: wfctx });
+        }
         setTimeout(() => getState().refresh_views(), 200);
         return {
           notify: `View saved: <a target="_blank" href="/view/${name}">${name}</a>`,
@@ -61,12 +157,17 @@ a view generation mode. The tool call only requires high-level details to start
     const enabled_vt_names = all_vt_names.filter(
       (vtnm) =>
         vts[vtnm].enable_copilot_viewgen ||
-        vts[vtnm].copilot_generate_view_prompt,
+        vts[vtnm].copilot_generate_view_prompt
     );
+    if (!enabled_vt_names.includes("Show")) enabled_vt_names.push("Show");
+    if (!enabled_vt_names.includes("Edit")) enabled_vt_names.push("Edit");
+    if (!enabled_vt_names.includes("List")) enabled_vt_names.push("List");
+    if (!enabled_vt_names.includes("Filter")) enabled_vt_names.push("Filter");
     //const roles = await User.get_roles();
     const tableless = enabled_vt_names.filter(
-      (vtnm) => vts[vtnm].tableless === true,
+      (vtnm) => vts[vtnm].tableless === true
     );
+    const roles = state.roles;
     const parameters = {
       type: "object",
       required: ["name", "viewpattern"],
@@ -76,7 +177,9 @@ a view generation mode. The tool call only requires high-level details to start
           type: "string",
         },
         viewpattern: {
-          description: `The type of view to generate. Some of the view descriptions: ${enabled_vt_names.map((vtnm) => `${vtnm}: ${vts[vtnm].description}.`).join(" ")}`,
+          description: `The type of view to generate. Some of the view descriptions: ${enabled_vt_names
+            .map((vtnm) => `${vtnm}: ${vts[vtnm].description}.`)
+            .join(" ")}`,
           type: "string",
           enum: enabled_vt_names,
         },
@@ -91,7 +194,7 @@ a view generation mode. The tool call only requires high-level details to start
           description:
             "The minimum role needed to access the view. For views accessible only by admin, use 'admin', pages with min_role 'public' is publicly accessible and also available to all users",
           type: "string",
-          enum: ["admin", "user", "public"],
+          enum: roles ? roles.map((r) => r.role) : ["admin", "user", "public"],
         },
       },
     };
@@ -107,73 +210,219 @@ a view generation mode. The tool call only requires high-level details to start
       process: async (input) => {
         return "Metadata received";
       },
-      postProcess: async ({ tool_call, req, generate }) => {
+      postProcess: async ({ tool_call, req, generate, chat }) => {
         const state = getState();
         const vt = state.viewtemplates[tool_call.input.viewpattern];
         const table =
           vt.tableless === true
             ? null
             : Table.findOne({ name: tool_call.input.table });
-        const flow = vt.configuration_workflow(req);
+
         const wfctx = { viewname: tool_call.input.name, table_id: table?.id };
-        let vt_prompt = "";
-        if (vt.copilot_generate_view_prompt) {
-          if (typeof vt.copilot_generate_view_prompt === "string")
-            vt_prompt = vt.copilot_generate_view_prompt;
-          else if (typeof vt.copilot_generate_view_prompt === "function")
-            vt_prompt = await vt.copilot_generate_view_prompt(tool_call.input);
+        const viewpattern = tool_call.input.viewpattern;
+        const builderModeByPattern = {
+          Show: "show",
+          Edit: "edit",
+          List: "listcolumns",
+          Filter: "filter",
+        };
+        const builderMode = builderModeByPattern[viewpattern];
+        if (builderMode) {
+          const extractText = (c) => {
+            if (typeof c === "string") return c;
+            if (Array.isArray(c)) {
+              const textPart = c.find(
+                (p) => p?.type === "text" || typeof p === "string"
+              );
+              return (
+                textPart?.text || (typeof textPart === "string" ? textPart : "")
+              );
+            }
+            return "";
+          };
+          const isToolResultMessage = (item) => {
+            if (!Array.isArray(item?.content)) return false;
+            return item.content.every((p) => p?.type === "tool_result");
+          };
+          const promptFromChat = Array.isArray(chat)
+            ? (() => {
+                const userMsgs = chat.filter(
+                  (item) =>
+                    item?.role === "user" &&
+                    item?.content &&
+                    !isToolResultMessage(item)
+                );
+                return userMsgs.length ? extractText(userMsgs[0].content) : "";
+              })()
+            : "";
+          const layoutPrompt = promptFromChat || tool_call.input.name || "";
+          wfctx.layout = await builderGen.run(
+            layoutPrompt,
+            builderMode,
+            table?.name,
+            null,
+            chat
+          );
+          if (table && viewpattern !== "Filter") {
+            const baseCfg = await initial_config_all_fields(false)({
+              table_id: table.id,
+            });
+            if (baseCfg?.columns) wfctx.columns = baseCfg.columns;
+          }
+          if (viewpattern === "Edit" && table) {
+            const layoutFieldNames = collectLayoutFieldNames(wfctx.layout);
+            const fields = table.fields || [];
+            const fixed = {};
+            for (const f of fields) {
+              if (f.primary_key || f.calculated) continue;
+              if (layoutFieldNames.has(f.name)) continue;
+              if (f.type === "Key" && f.reftable_name === "users") {
+                fixed[`preset_${f.name}`] = "LoggedIn";
+                fixed[`_block_${f.name}`] = true;
+              }
+            }
+            if (Object.keys(fixed).length > 0) wfctx.fixed = fixed;
+            wfctx.destination_type = "Back to referer";
+          }
+          if (viewpattern === "Filter") {
+            const filterFieldSegment = findFilterFieldSegment(wfctx.layout);
+            if (filterFieldSegment) {
+              const normalized = normalizeFilterField(filterFieldSegment);
+              wfctx.layout = normalized;
+              wfctx.columns = [toFilterColumn(normalized)];
+            }
+          }
         }
 
-        for (const step of flow.steps) {
-          const form = await step.form(wfctx);
-          const properties = {};
-          //TODO onlyWhen
-          for (const field of form.fields) {
-            //TODO showIf
-            properties[field.name] = {
-              description:
-                field.copilot_description ||
-                `${field.label}.${field.sublabel ? ` ${field.sublabel}` : ""}`,
-              ...fieldProperties(field),
-            };
+        if (
+          viewpattern === "Show" ||
+          viewpattern === "Edit" ||
+          viewpattern === "Filter"
+        ) {
+          // No extra configuration steps for these modes.
+        } else {
+          const flow = vt.configuration_workflow(req);
+          let vt_prompt = "";
+          if (vt.copilot_generate_view_prompt) {
+            if (typeof vt.copilot_generate_view_prompt === "string")
+              vt_prompt = vt.copilot_generate_view_prompt;
+            else if (typeof vt.copilot_generate_view_prompt === "function")
+              vt_prompt = await vt.copilot_generate_view_prompt(
+                tool_call.input
+              );
           }
 
-          const answer = await generate(
-            `${vt_prompt ? vt_prompt + "\n\n" : ""}Now generate the ${step.name} details of the view by calling the generate_view_details tool`,
-            {
-              tools: [
-                {
+          const prefilledFields = new Set();
+          if (wfctx.layout !== undefined) prefilledFields.add("layout");
+          if (wfctx.columns !== undefined) prefilledFields.add("columns");
+
+          // For List views: pre-fill view_to_create with the best Edit view for the table
+          if (viewpattern === "List" && table) {
+            const candidateViews = await View.find_table_views_where(
+              table.id,
+              ({ state_fields, viewrow }) =>
+                viewrow.name !== tool_call.input.name &&
+                state_fields.every((sf) => !sf.required)
+            );
+            if (candidateViews.length > 0) {
+              const editView =
+                candidateViews.find((v) =>
+                  v.name.toLowerCase().includes("edit")
+                ) || candidateViews[0];
+              wfctx.view_to_create =
+                editView.select_option?.name || editView.name;
+              wfctx.create_view_display = "Popup";
+              wfctx.create_view_location = "Top right";
+              prefilledFields.add("view_to_create");
+              prefilledFields.add("create_view_display");
+              prefilledFields.add("create_view_location");
+            }
+          }
+
+          for (const step of flow.steps) {
+            if (typeof step.form !== "function") continue;
+            const form = await step.form(wfctx);
+            const properties = {};
+            //TODO onlyWhen
+            for (const field of form.fields) {
+              if (prefilledFields.has(field.name)) continue;
+              //TODO showIf
+              properties[field.name] = {
+                description:
+                  field.copilot_description ||
+                  `${field.label}.${
+                    field.sublabel ? ` ${field.sublabel}` : ""
+                  }`,
+                ...fieldProperties(field),
+              };
+              if (!properties[field.name].type) {
+                properties[field.name].type = "string";
+              }
+            }
+
+            if (!Object.keys(properties).length) continue;
+
+            const answer = await generate(
+              `${vt_prompt ? vt_prompt + "\n\n" : ""}Now generate the ${
+                step.name
+              } details of the view by calling the generate_view_details tool`,
+              {
+                tools: [
+                  {
+                    type: "function",
+                    function: {
+                      name: "generate_view_details",
+                      description: "Provide view details",
+                      parameters: {
+                        type: "object",
+                        properties,
+                      },
+                    },
+                  },
+                ],
+                tool_choice: {
                   type: "function",
                   function: {
                     name: "generate_view_details",
-                    description: "Provide view details",
-                    parameters: {
-                      type: "object",
-                      properties,
-                    },
                   },
                 },
-              ],
-              tool_choice: {
-                type: "function",
-                function: {
-                  name: "generate_view_details",
-                },
-              },
-            },
-          );
-          const tc = answer.getToolCalls()[0];
-          Object.assign(wfctx, tc.input);
+              }
+            );
+            const tc = answer.getToolCalls()[0];
+            await getState().functions.llm_add_message.run(
+              "tool_response",
+              { type: "text", value: "Details provided" },
+              { chat, tool_call: tc }
+            );
+            Object.assign(wfctx, tc.input);
+          }
         }
+        const roleName = tool_call.input.min_role || "public";
+        const rolesState = getState().roles;
+        const min_role = rolesState
+          ? (rolesState.find((r) => r.role === roleName) || { id: 100 }).id
+          : { admin: 1, public: 100, user: 80 }[roleName] ?? 100;
         const view = new View({
           name: tool_call.input.name,
           viewtemplate: tool_call.input.viewpattern,
           table,
-          min_role: { admin: 1, public: 100, user: 80 }[
-            tool_call.input.min_role
-          ],
+          table_id: table?.id,
+          min_role,
           configuration: wfctx,
         });
+        if (this.yoloMode) {
+          await this.userActions.build_copilot_view_gen({
+            wfctx,
+            name: tool_call.input.name,
+            viewpattern: tool_call.input.viewpattern,
+            table: tool_call.input.table,
+            min_role: tool_call.input.min_role,
+          });
+          return {
+            stop: true,
+            add_response: `View ${tool_call.input.name} created.`,
+          };
+        }
         const runres = await view.run({}, { req });
         return {
           stop: true,
@@ -181,7 +430,7 @@ a view generation mode. The tool call only requires high-level details to start
             pre(JSON.stringify(wfctx, null, 2)) +
             div(
               { style: { maxHeight: 800, maxWidth: 500, overflow: "scroll" } },
-              runres,
+              runres
             ),
           add_user_action: {
             name: "build_copilot_view_gen",

package/agent-skills/workflow.js

@@ -550,11 +550,50 @@ class GenerateWorkflowSkill {
     ensureActionCatalog();
   }
 
+  static async configFields() {
+    return [
+      {
+        name: "context_vars",
+        label: "Initial context variables",
+        input_type: "code",
+        attributes: { mode: "application/json" },
+        sublabel:
+          'JSON object of key-value pairs pre-loaded into the workflow context at startup (e.g. {"ELEVENLABS_API_KEY": "sk-..."}). Keys are available by name in every run_js_code step.',
+      },
+    ];
+  }
+
+  _parseContextVars() {
+    if (!this.context_vars) return null;
+    try {
+      const vars =
+        typeof this.context_vars === "string"
+          ? JSON.parse(this.context_vars)
+          : this.context_vars;
+      return Object.keys(vars).length ? vars : null;
+    } catch {
+      return null;
+    }
+  }
+
   async systemPrompt() {
-    return await GenerateWorkflow.system_prompt();
+    const base = await GenerateWorkflow.system_prompt();
+    const vars = this._parseContextVars();
+    if (!vars) return base;
+    const keyList = Object.keys(vars).join(", ");
+    return (
+      base +
+      `\n\nThe following values are pre-loaded into the workflow context before the first step runs: ${keyList}. ` +
+      `Use them directly by name in run_js_code steps (e.g. \`${
+        Object.keys(vars)[0]
+      }\`) ` +
+      `or via the context object (e.g. \`context.${Object.keys(vars)[0]}\`). ` +
+      `Do not ask the user to supply these values — they are already available.`
+    );
   }
 
   get userActions() {
+    const context_vars = this._parseContextVars();
     return {
       async apply_copilot_workflow({ user, ...raw }) {
         const payload = ensureWorkflowHasSteps(normalizeWorkflowPayload(raw));
@@ -563,7 +602,11 @@ class GenerateWorkflowSkill {
           return {
             notify: `Cannot create workflow: ${analysis.blocking.join("; ")}`,
           };
-        const result = await GenerateWorkflow.execute(payload, { user });
+        const result = await GenerateWorkflow.execute(
+          payload,
+          { user },
+          context_vars
+        );
         return {
           notify:
             result?.postExec ||
@@ -608,6 +651,13 @@ class GenerateWorkflowSkill {
         const canCreate =
           analysis.blocking.length === 0 &&
           preparedPayload.workflow_steps.length > 0;
+        if (this.yoloMode && canCreate) {
+          await this.userActions.apply_copilot_workflow(preparedPayload);
+          return {
+            stop: true,
+            add_response: `Workflow ${preparedPayload.workflow_name || "(unnamed)"} created.`,
+          };
+        }
         return {
           stop: true,
           add_response: `${issuesHtml}${previewHtml}`,

package/app-constructor/common.js

@@ -0,0 +1,12 @@
+const viewname = "Saltcorn AppConstructor (experimental)";
+
+const tool_choice = (tool_name) => ({
+  tool_choice: {
+    type: "function",
+    function: {
+      name: tool_name,
+    },
+  },
+});
+
+module.exports = { viewname, tool_choice };

package/app-constructor/errors.js

@@ -0,0 +1,102 @@
+const Field = require("@saltcorn/data/models/field");
+const Table = require("@saltcorn/data/models/table");
+const Form = require("@saltcorn/data/models/form");
+const MetaData = require("@saltcorn/data/models/metadata");
+const View = require("@saltcorn/data/models/view");
+const Trigger = require("@saltcorn/data/models/trigger");
+const { findType } = require("@saltcorn/data/models/discovery");
+const { save_menu_items } = require("@saltcorn/data/models/config");
+const db = require("@saltcorn/data/db");
+const WorkflowRun = require("@saltcorn/data/models/workflow_run");
+const {
+  localeDateTime,
+  renderForm,
+  mkTable,
+  post_delete_btn,
+} = require("@saltcorn/markup");
+const {
+  div,
+  script,
+  domReady,
+  pre,
+  code,
+  input,
+  h4,
+  style,
+  h5,
+  button,
+  text_attr,
+  i,
+  p,
+  span,
+  small,
+  form,
+  textarea,
+} = require("@saltcorn/markup/tags");
+const { getState } = require("@saltcorn/data/db/state");
+const renderLayout = require("@saltcorn/markup/layout");
+const { viewname } = require("./common");
+
+const errorList = async (req) => {
+  const errs = await MetaData.find({
+    type: "CopilotConstructMgr",
+    name: "error",
+  });
+  if (errs.length) {
+    return div(
+      { class: "mt-2" },
+      mkTable(
+        [
+          { label: "Status", key: (m) => m.body.status },
+          {
+            label: "Error",
+            key: (m) => pre(JSON.stringify(m.body.error, null, 2)),
+          },
+          {
+            label: "Delete",
+            key: (r) =>
+              button(
+                {
+                  class: "btn btn-outline-danger btn-sm",
+                  onclick: `view_post("${viewname}", "del_err", {id:${r.id}})`,
+                },
+                i({ class: "fas fa-trash-alt" }),
+              ),
+          },
+        ],
+        errs,
+      ),
+      button(
+        {
+          class: "btn btn-outline-danger",
+          onclick: `view_post("${viewname}", "del_all_errs")`,
+        },
+        "Delete all",
+      ),
+    );
+  } else {
+    return div({ class: "mt-2" }, p("No errors"));
+  }
+};
+
+const del_err = async (table_id, viewname, config, body, { req, res }) => {
+  const r = await MetaData.findOne({
+    id: body.id,
+  });
+
+  if (!r) throw new Error("Error not found");
+  await r.delete();
+  return { json: { reload_page: true } };
+};
+const del_all_errs = async (table_id, viewname, config, body, { req, res }) => {
+  const rs = await MetaData.find({
+    type: "CopilotConstructMgr",
+    name: "error",
+  });
+  for (const r of rs) await r.delete();
+  return { json: { reload_page: true } };
+};
+
+const error_routes = { del_err, del_all_errs };
+
+module.exports = { errorList, error_routes };