@saltcorn/copilot 0.7.5 → 0.8.0

package/agent-skills/viewgen.js

@@ -15,6 +15,90 @@ const {
 } = 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";
 
@@ -27,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() {
@@ -50,6 +137,10 @@ a view generation mode. The tool call only requires high-level details to start
           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>`,
@@ -66,13 +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"],
@@ -82,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,
         },
@@ -97,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"],
         },
       },
     };
@@ -122,25 +219,87 @@ a view generation mode. The tool call only requires high-level details to start
             : Table.findOne({ name: tool_call.input.table });
 
         const wfctx = { viewname: tool_call.input.name, table_id: table?.id };
-        if (tool_call.input.viewpattern === "Show") {
+        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)
-            ? [...chat]
-                .reverse()
-                .find((item) => item?.role === "user" && item?.content)?.content
+            ? (() => {
+                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,
-            "show",
+            builderMode,
             table?.name,
-            chat,
+            null,
+            chat
           );
-          if (table) {
+          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)];
+            }
+          }
+        }
+
+        if (
+          viewpattern === "Show" ||
+          viewpattern === "Edit" ||
+          viewpattern === "Filter"
+        ) {
+          // No extra configuration steps for these modes.
         } else {
           const flow = vt.configuration_workflow(req);
           let vt_prompt = "";
@@ -149,26 +308,64 @@ a view generation mode. The tool call only requires high-level details to start
               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,
+                tool_call.input
               );
           }
 
+          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}` : ""}`,
+                  `${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`,
+              `${vt_prompt ? vt_prompt + "\n\n" : ""}Now generate the ${
+                step.name
+              } details of the view by calling the generate_view_details tool`,
               {
                 tools: [
                   {
@@ -189,22 +386,43 @@ a view generation mode. The tool call only requires high-level details to start
                     name: "generate_view_details",
                   },
                 },
-              },
+              }
             );
             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,
           table_id: table?.id,
-          min_role: { admin: 1, public: 100, user: 80 }[
-            tool_call.input.min_role || "public"
-          ],
+          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,
@@ -212,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 };