@saltcorn/copilot 0.7.5 → 0.8.1

package/builder-schema.js

@@ -41,6 +41,23 @@ const TOOLBOX_BY_MODE = {
   ],
   list: [
     "blank",
+    "list_columns",
+    "list_column",
+    "field",
+    "join_field",
+    "view_link",
+    "action",
+    "link",
+    "aggregation",
+    "view",
+    "container",
+    "dropdown_menu",
+    "line_break",
+  ],
+  listcolumns: [
+    "blank",
+    "list_columns",
+    "list_column",
     "field",
     "join_field",
     "view_link",
@@ -131,7 +148,6 @@ const buildSegmentDef = ({
 });
 
 const buildBuilderSchema = ({ mode, ctx }) => {
-  console.log({ ctx });
   const normalizedMode = (mode || ctx?.mode || "show").toLowerCase();
   const fields = ctx?.fields || [];
   const actions = ctx?.actions || [];
@@ -141,9 +157,13 @@ const buildBuilderSchema = ({ mode, ctx }) => {
     Array.isArray(rawIcons) ? rawIcons : Object.keys(rawIcons)
   ).slice(0, 15);
 
-  const fieldNames = fields.map((f) => f.name).filter(Boolean);
+  const isEditMode = normalizedMode === "edit" || normalizedMode === "filter";
+  const visibleFields = isEditMode
+    ? fields.filter((f) => !f.calculated)
+    : fields;
+  const fieldNames = visibleFields.map((f) => f.name).filter(Boolean);
   const fieldviewOptions = Array.from(
-    new Set(fields.flatMap((f) => f.fieldviews || []).filter(Boolean)),
+    new Set(visibleFields.flatMap((f) => f.fieldviews || []).filter(Boolean))
   );
 
   const defs = {
@@ -240,11 +260,11 @@ const buildBuilderSchema = ({ mode, ctx }) => {
     },
     imageLocation: makeEnum(
       IMAGE_LOCATIONS,
-      "Image location for card/container backgrounds.",
+      "Image location for card/container backgrounds."
     ),
     imageSize: makeEnum(
       IMAGE_SIZES,
-      "Image sizing for Card or Body locations.",
+      "Image sizing for Card or Body locations."
     ),
     gradStartColor: {
       type: "string",
@@ -633,7 +653,7 @@ const buildBuilderSchema = ({ mode, ctx }) => {
     { $ref: "#/$defs/join_field" },
     { $ref: "#/$defs/list_column" },
     { $ref: "#/$defs/list_columns" },
-    { $ref: "#/$defs/page" },
+    { $ref: "#/$defs/page" }
   );
 
   Object.assign(defs, {

package/chat-copilot.js

@@ -382,6 +382,7 @@ const actionClasses = [
   require("./actions/generate-workflow"),
   require("./actions/generate-tables"),
   require("./actions/generate-js-action"),
+  require("./actions/generate-trigger"),
   require("./actions/generate-page"),
   require("./actions/generate-view"),
 ];

package/common.js

@@ -14,6 +14,24 @@ const MarkdownIt = require("markdown-it"),
   md = new MarkdownIt();
 const HTMLParser = require("node-html-parser");
 
+const getLlmConfigurationSafe = async () => {
+  const fn = getState().functions?.llm_get_configuration;
+  if (!fn?.run) return null;
+  try {
+    return await fn.run();
+  } catch (err) {
+    return null;
+  }
+};
+
+const canUseResponseFormat = (llmConfig) => {
+  const backend = llmConfig?.backend;
+  if (!backend) return false;
+  if (backend === "AI SDK") return true;
+  if (backend === "OpenAI") return !!llmConfig?.responses_api;
+  return false;
+};
+
 const boxHandledStyles = new Set([
   "margin",
   "margin-top",
@@ -364,4 +382,6 @@ module.exports = {
   splitContainerStyle,
   walk_response,
   parseHTML,
+  getLlmConfigurationSafe,
+  canUseResponseFormat,
 };

package/copilot-as-agent.js

@@ -3,6 +3,7 @@ const Table = require("@saltcorn/data/models/table");
 const Form = require("@saltcorn/data/models/form");
 const View = require("@saltcorn/data/models/view");
 const Trigger = require("@saltcorn/data/models/trigger");
+const Plugin = require("@saltcorn/data/models/plugin");
 const { findType } = require("@saltcorn/data/models/discovery");
 const { save_menu_items } = require("@saltcorn/data/models/config");
 const db = require("@saltcorn/data/db");
@@ -46,6 +47,12 @@ const get_agent_view = () => {
         { skill_type: "Database design" },
         { skill_type: "Generate Workflow" },
         { skill_type: "Generate View" },
+        { skill_type: "Registry editor" },
+        { skill_type: "Javascript Action" },
+        { skill_type: "Generate trigger" },
+        ...(typeof Plugin.loadAndSaveNewPlugin === "function"
+          ? [{ skill_type: "Install Plugin" }]
+          : []),
       ],
     },
   });
@@ -64,7 +71,6 @@ const run = async (table_id, viewname, cfg, state, reqres) => {
 };
 
 const interact = async (table_id, viewname, config, body, reqres) => {
-  console.log("copilot interact with body", body);
   const view = get_agent_view();
   return await view.runRoute("interact", body, reqres.res, reqres);
 };

package/index.js

@@ -1,15 +1,27 @@
 const Workflow = require("@saltcorn/data/models/workflow");
 const Form = require("@saltcorn/data/models/form");
 const { features } = require("@saltcorn/data/db/state");
+const db = require("@saltcorn/data/db");
+const Plugin = require("@saltcorn/data/models/plugin");
+const { viewname } = require("./app-constructor/common.js");
+
+const headers = [
+  {
+    script: `/static_assets/${db.connectObj.version_tag}/mermaid.min.js`,
+    onlyViews: [viewname],
+  },
+];
 
 module.exports = {
   sc_plugin_api_version: 1,
+  headers,
   dependencies: ["@saltcorn/large-language-model", "@saltcorn/agents"],
   viewtemplates: features.workflows
     ? [
         require("./chat-copilot"),
         require("./user-copilot"),
         require("./copilot-as-agent"),
+        require("./app-constructor/view.js"),
       ]
     : [require("./action-builder"), require("./database-designer")],
   functions: features.workflows
@@ -17,15 +29,25 @@ module.exports = {
         copilot_standard_prompt: require("./standard-prompt.js"),
         copilot_generate_layout: require("./builder-gen.js"),
         copilot_generate_workflow: require("./workflow-gen"),
+        copilot_generate_javascript: require("./js-code-gen.js"),
       }
     : {},
-  actions: { copilot_generate_page: require("./page-gen-action") },
+  actions: {
+    copilot_generate_page: require("./page-gen-action"),
+    app_constructor_feedback: require("./app-constructor/feedback-action.js"),
+  },
   exchange: {
     agent_skills: [
       require("./agent-skills/pagegen.js"),
       require("./agent-skills/database-design.js"),
       require("./agent-skills/workflow.js"),
       require("./agent-skills/viewgen.js"),
+      require("./agent-skills/registry-editor.js"),
+      require("./agent-skills/js-action.js"),
+      require("./agent-skills/triggergen.js"),
+      ...(typeof Plugin.loadAndSaveNewPlugin === "function"
+        ? [require("./agent-skills/install-plugin.js")]
+        : []),
     ],
   },
 };

package/js-code-gen.js

@@ -0,0 +1,65 @@
+const { getState } = require("@saltcorn/data/db/state");
+const { getPromptFromTemplate } = require("./common");
+const Table = require("@saltcorn/data/models/table");
+
+const stripCodeFences = (text) => {
+  let s = String(text || "").trim();
+  s = s.replace(/^```(?:javascript|js|ts|typescript)?\s*\n?/i, "");
+  s = s.replace(/\n?```\s*$/i, "");
+  return s.trim();
+};
+
+const getTableContext = (table_name) => {
+  if (!table_name) return null;
+  const table = Table.findOne({ name: table_name });
+  if (!table) return null;
+  const fields = table.getFields ? table.getFields() : table.fields || [];
+  return { table, fieldNames: fields.map((f) => f.name) };
+};
+
+module.exports = {
+  run: async (description, existing_code, table_name) => {
+    const systemPrompt = await getPromptFromTemplate(
+      "action-builder.txt",
+      description
+    );
+
+    const tableCtx = getTableContext(table_name);
+    let contextInfo;
+    if (tableCtx) {
+      contextInfo =
+        `\n\nThis action runs in the context of the "${table_name}" table. ` +
+        `Available variables: row (with fields: ${tableCtx.fieldNames.join(", ")}), ` +
+        `user, table, console, Actions, Table, File, User.`;
+    } else {
+      contextInfo =
+        "\n\nAvailable variables: user, console, Actions, Table, File, User.";
+    }
+
+    let prompt;
+    if (existing_code && existing_code.trim()) {
+      prompt =
+        `Modify the following JavaScript code based on this instruction: ${description}\n\n` +
+        `Existing code:\n${existing_code}` +
+        `${contextInfo}\n\n` +
+        `Return only the modified JavaScript code. Do not include any explanation or markdown code fences.`;
+    } else {
+      prompt =
+        `Generate JavaScript code for the following task: ${description}` +
+        `${contextInfo}\n\n` +
+        `Only return the JavaScript code. Do not include any explanation or markdown code fences.`;
+    }
+
+    const result = await getState().functions.llm_generate.run(prompt, {
+      systemPrompt,
+    });
+    return stripCodeFences(result);
+  },
+  isAsync: true,
+  description: "Generate JavaScript code for an action",
+  arguments: [
+    { name: "description", type: "String" },
+    { name: "existing_code", type: "String" },
+    { name: "table_name", type: "String" },
+  ],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saltcorn/copilot",
-  "version": "0.7.5",
+  "version": "0.8.1",
   "description": "AI assistant for building Saltcorn applications",
   "main": "index.js",
   "dependencies": {

package/relation-paths.js

@@ -0,0 +1,236 @@
+const { RelationsFinder, RelationType } = require("@saltcorn/common-code");
+
+/**
+ * Relation path documentation included in LLM system prompts (viewgen, builder-gen).
+ *
+ * TWO FORMATS EXIST:
+ *
+ * New format (always generate this):
+ *   view: "viewname"  +  relation: ".sourcetable.segment1.segment2..."
+ *
+ *   Segment types:
+ *     Outbound FK (to parent):    FK field name alone,         e.g. trip_id
+ *     Inbound FK  (child rows):   childtable$fkfield,          e.g. packing_items$trip_id
+ *
+ *   Examples:
+ *     .trips.packing_items$trip_id            ChildList:    all packing_items for a trip
+ *     .packing_items.trip_id                  ParentShow:   the trip that owns a packing item
+ *     .artists.artist_plays_on_album$artist.album  ChildList through a join table
+ *     .users.orders$user_id.order_lines$order_id   RelationPath: multi-level
+ *
+ * Legacy format (may appear in existing configs — do not generate, understand only):
+ *   The type and path are encoded together in the view field, no separate relation field.
+ *     "Own:viewname"                     → same table, no relation
+ *     "ParentShow:viewname.table.fkfield" → outbound FK to parent
+ *     "ChildList:viewname.table.inbkey"  → inbound FK, one-to-many
+ *     "OneToOneShow:viewname.table.inbkey" → inbound FK, unique
+ *     "Independent:viewname"             → no FK relationship
+ *
+ * Relation types by new-format path structure:
+ *   Own          – zero segments, source and target are the same table
+ *   ParentShow   – single outbound-FK segment
+ *   OneToOneShow – single inbound-FK segment on a unique field
+ *   ChildList    – one or more inbound-FK segments (may mix outbound for join tables)
+ *   RelationPath – complex multi-level path mixing both segment types
+ */
+const RELATION_PATH_DOC = `
+## Relation paths
+
+Relation paths connect a view_link column or embedded view (type "view") segment to its
+target view. There are two formats — **new** (preferred) and **legacy** (read-only).
+
+---
+
+### New format (always use this when generating or updating)
+
+Two separate fields:
+- \`view\`: just the view name, e.g. \`"packing_items_list"\`
+- \`relation\`: a dot-separated path string, e.g. \`".trips.packing_items$trip_id"\`
+
+**Path string format:** \`.sourcetable.segment1.segment2...\`
+
+Segment types:
+- **Outbound FK** (navigate to a parent): FK field name alone — e.g. \`trip_id\`
+- **Inbound FK** (collect child rows): \`childtable$fkfield\` — e.g. \`packing_items$trip_id\`
+
+Examples:
+| relation string | type | meaning |
+|---|---|---|
+| \`.trips.packing_items$trip_id\` | ChildList | all packing_items for a trip |
+| \`.packing_items.trip_id\` | ParentShow | the trip that owns a packing_item |
+| \`.artists.artist_plays_on_album$artist.album\` | ChildList | albums via join table |
+| \`.users.orders$user_id.order_lines$order_id\` | RelationPath | multi-level |
+
+---
+
+### Legacy format (you may encounter this in existing configs — do not generate it)
+
+The type and path are encoded together inside the \`view\` field as a colon-prefixed string.
+There is no separate \`relation\` field.
+
+| legacy view field | equivalent new relation |
+|---|---|
+| \`"Own:viewname"\` | \`view: "viewname"\`, no relation |
+| \`"ParentShow:viewname.table.fkfield"\` | \`relation: ".sourcetable.fkfield"\` |
+| \`"ChildList:viewname.table.inbkey"\` | \`relation: ".sourcetable.childtable$inbkey"\` |
+| \`"OneToOneShow:viewname.table.inbkey"\` | \`relation: ".sourcetable.childtable$inbkey"\` |
+| \`"Independent:viewname"\` | \`view: "viewname"\`, no relation |
+
+When you read an existing view config and see a legacy \`view\` value like \`"ChildList:trips_list.packing_items.trip_id"\`, parse it as: type=ChildList, view=trips_list, relation=.sourcetable.packing_items$trip_id. When writing back, convert to the new format.
+
+---
+
+### Using get_relation_paths
+
+Call it **once** with all source_table/target_view pairs you need — do not make separate calls per pair. The tool returns paths in the new RelationPath format; always write back in the new format, even if you read legacy strings from an existing config.
+
+When multiple paths are returned for one pair, pick by matching the relation type to what the target view is meant to show:
+- **ChildList** — target view shows multiple rows belonging to the current row (e.g. packing items for a trip).
+- **ParentShow** — target view shows the single parent the current row belongs to (e.g. the trip for a packing item).
+- **OneToOneShow** — exactly one related child row via a unique FK.
+- **Own** — target view is on the same table (no FK traversal needed).
+- If multiple paths of the same type exist (e.g. a table has two FKs pointing to the same target), pick the one whose FK field name best matches the semantic relationship in the task.
+- Prefer shorter paths (fewer segments) unless a longer one is clearly more appropriate.
+`;
+
+const typeToLabel = (type) => {
+  if (type === RelationType.OWN)
+    return "Own – source and target are the same table (no relation needed)";
+  if (type === RelationType.INDEPENDENT)
+    return "Independent – no FK relationship exists";
+  if (type === RelationType.PARENT_SHOW)
+    return "ParentShow – outbound FK to a parent record (many-to-one)";
+  if (type === RelationType.ONE_TO_ONE_SHOW)
+    return "OneToOneShow – unique inbound FK (one-to-one)";
+  if (type === RelationType.CHILD_LIST)
+    return "ChildList – inbound FK, one parent → many child rows";
+  return "RelationPath – complex multi-level path";
+};
+
+/**
+ * @param {string} sourceTableName
+ * @param {string} targetViewName
+ * @param {{ tables, views }} schemaData  pre-fetched via build_schema_data()
+ * @returns {Array<Relation>}  raw Relation objects from RelationsFinder
+ */
+function getRelationPaths(sourceTableName, targetViewName, schemaData) {
+  if (!schemaData) return [];
+  try {
+    const finder = new RelationsFinder(schemaData.tables, schemaData.views, 6);
+    return finder.findRelations(sourceTableName, targetViewName, []);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Resolve multiple source_table/target_view pairs against pre-fetched schema data.
+ * All per-pair work is synchronous — call build_schema_data() once before invoking this.
+ * @param {Array<{source_table: string, target_view: string}>} pairs
+ * @param {{ tables, views }} schemaData
+ * @returns {Array<string>}  one formatted result string per pair
+ */
+function getRelationPathsForPairs(pairs, schemaData) {
+  if (!schemaData) return pairs.map(({ source_table, target_view }) =>
+    formatRelationPathResult(source_table, target_view, { error: "Schema data unavailable" })
+  );
+  const finder = new RelationsFinder(schemaData.tables, schemaData.views, 6);
+  return pairs.map(({ source_table, target_view }) => {
+    const targetView = (schemaData.views || []).find((v) => v.name === target_view);
+    if (!targetView)
+      return formatRelationPathResult(source_table, target_view, {
+        error: `View "${target_view}" not found in current schema`,
+      });
+    let relations;
+    try {
+      relations = finder.findRelations(source_table, target_view, []);
+    } catch (e) {
+      return formatRelationPathResult(source_table, target_view, {
+        error: `Failed to find relations: ${e.message}`,
+      });
+    }
+    return formatRelationPathResult(source_table, target_view, {
+      paths: relations.map((r) => ({
+        relation_string: r.relationString,
+        type: String(r.type),
+        label: typeToLabel(r.type),
+      })),
+    });
+  });
+}
+
+/**
+ * Pick the most useful relation from a list: Own > Parent > Child > first.
+ * Used as a fallback in builder-gen when the model doesn't specify a relation.
+ */
+function pickBestRelation(relations) {
+  if (!relations.length) return null;
+  let own = null,
+    parent = null,
+    child = null;
+  for (const r of relations) {
+    if (r.type === RelationType.OWN) own = r;
+    else if (r.type === RelationType.PARENT_SHOW) parent = r;
+    else if (
+      r.type === RelationType.CHILD_LIST ||
+      r.type === RelationType.ONE_TO_ONE_SHOW
+    )
+      child = r;
+  }
+  return own || parent || child || relations[0];
+}
+
+/**
+ * Format the result of getRelationPaths into a human-readable string for the model.
+ * Handles both found and not-found cases for one source_table/target_view pair.
+ */
+function formatRelationPathResult(source_table, target_view, result) {
+  if (result.error) return `${source_table} → ${target_view}: ${result.error}`;
+  if (!result.paths.length)
+    return `${source_table} → ${target_view}: no relation paths found (no FK relationship)`;
+  const lines = result.paths
+    .map((p) => `    "${p.relation_string}" — ${p.label}`)
+    .join("\n");
+  return `${source_table} → ${target_view}:\n${lines}`;
+}
+
+const GET_RELATION_PATHS_FUNCTION = {
+  name: "get_relation_paths",
+  description:
+    "Get all valid relation path strings for one or more source_table/target_view pairs. " +
+    "Call this ONCE with all pairs you need before setting any 'relation' property on " +
+    "view_link columns or embedded view (type 'view') segments.",
+  parameters: {
+    type: "object",
+    required: ["pairs"],
+    properties: {
+      pairs: {
+        type: "array",
+        description:
+          "All source_table/target_view pairs you need relation paths for. Include every pair in one call.",
+        items: {
+          type: "object",
+          required: ["source_table", "target_view"],
+          properties: {
+            source_table: {
+              type: "string",
+              description: "The table of the view being built or updated.",
+            },
+            target_view: {
+              type: "string",
+              description: "The view to link to or embed.",
+            },
+          },
+        },
+      },
+    },
+  },
+};
+
+module.exports = {
+  RELATION_PATH_DOC,
+  GET_RELATION_PATHS_FUNCTION,
+  getRelationPaths,
+  getRelationPathsForPairs,
+  pickBestRelation,
+};

package/tests/builder-gen.test.js

@@ -0,0 +1,56 @@
+const { getState } = require("@saltcorn/data/db/state");
+const View = require("@saltcorn/data/models/view");
+const Table = require("@saltcorn/data/models/table");
+const Plugin = require("@saltcorn/data/models/plugin");
+const Trigger = require("@saltcorn/data/models/trigger");
+const WorkflowStep = require("@saltcorn/data/models/workflow_step");
+const WorkflowRun = require("@saltcorn/data/models/workflow_run");
+
+const { mockReqRes } = require("@saltcorn/data/tests/mocks");
+const { afterAll, beforeAll, describe, it, expect } = require("@jest/globals");
+
+afterAll(require("@saltcorn/data/db").close);
+beforeAll(async () => {
+  await require("@saltcorn/data/db/reset_schema")();
+  await require("@saltcorn/data/db/fixtures")();
+
+  getState().registerPlugin("base", require("@saltcorn/data/base-plugin"));
+});
+
+/* 
+ 
+ RUN WITH:
+  saltcorn dev:plugin-test -d ~/copilot -o ~/large-language-model/
+ 
+ */
+
+jest.setTimeout(60000);
+
+const configs = require("./configs.js");
+
+for (const nameconfig of configs) {
+  const { name, ...config } = nameconfig;
+  describe("copilot_generate_layout with " + name, () => {
+    beforeAll(async () => {
+      getState().registerPlugin(
+        "@saltcorn/large-language-model",
+        require("@saltcorn/large-language-model"),
+        config,
+      );
+      getState().registerPlugin("@saltcorn/copilot", require(".."));
+    });
+    for (const mode of ["page", "show", "edit", "filter"])
+      it("generates simple layout in mode " + mode, async () => {
+        const genres = await getState().functions.copilot_generate_layout.run(
+          "A container with a text element that says Hello World in H3",
+          mode,
+          mode === "page" ? null : "books",
+        );
+        const innerRes = genres.above ? genres.above[0] : genres;
+        expect(innerRes.type).toBe("container");
+        expect(innerRes.contents.type).toBe("blank");
+        expect(innerRes.contents.contents).toBe("Hello World");
+        expect(innerRes.contents.textStyle).toBe("h3");
+      });
+  });
+}