@saltcorn/copilot 0.8.1 → 0.8.3

package/builder-gen.js

@@ -27,13 +27,9 @@ designated as ownership fields (set automatically from the logged-in user). \
 All other foreign key fields — including parent-context keys like trip_id — MUST appear as \
 selector inputs; Saltcorn auto-fills them from the URL state when opened in context.`;
 
-const EDIT_FIELDVIEW_SELECTION = `\
-For date fields always prefer fieldview "flatpickr" when available — it provides the best user experience \
-and works for both regular dates and day-only dates. \
-Only use fieldview "edit_day" as a fallback when the field has day_only=true and flatpickr is not installed. \
-For String fields that have an options attribute (a comma-separated list of fixed choices), \
-use fieldview "select" — this renders a dropdown with those options. \
-Do not use "select_by_code" for fields with fixed options.`;
+const {
+  fieldview_selection_rules: EDIT_FIELDVIEW_SELECTION,
+} = require("./app-constructor/prompts");
 
 const EDIT_LAYOUT_STRUCTURE = `\
 Every field MUST be preceded by a label. \
@@ -79,7 +75,9 @@ only use "show_with_html" when the task explicitly requires rendering HTML conte
 
 const LISTCOLUMNS_VIEW_LINK = `\
 A view_link that opens the detail of a row MUST point to a Show-type view (viewtemplate "Show"). \
-Only include such a view_link if a Show view for this table is listed in the available views.`;
+Only include such a view_link if a Show view for this table is listed in the available views. \
+Every view_link requires a "relation" string — you MUST call get_relation_paths before generating the layout \
+whenever the layout will contain any view_link or embedded view segment.`;
 
 // ── Composed MODE_GUIDANCE ────────────────────────────────────────────────────
 
@@ -805,7 +803,8 @@ const normalizeSegment = (segment, ctx) => {
       let viewLabel = clone.view_label || clone.view;
       let isFormula = clone.isFormula || {};
       const tmplMatch =
-        typeof viewLabel === "string" && viewLabel.match(/^\{\{\s*(.+?)\s*\}\}$/);
+        typeof viewLabel === "string" &&
+        viewLabel.match(/^\{\{\s*(.+?)\s*\}\}$/);
       if (tmplMatch) {
         viewLabel = tmplMatch[1];
         isFormula = { ...isFormula, label: true };
@@ -843,7 +842,9 @@ const normalizeSegment = (segment, ctx) => {
         child == null ? null : normalizeSegment(child, ctx)
       );
       if (!besides.some(Boolean)) return null;
-      return { ...clone, besides, list_columns: true };
+      // Drop 'type' — List viewtemplate expects { besides, list_columns: true } with no type field
+      const { type: _t, ...rest } = clone;
+      return { ...rest, besides, list_columns: true };
     }
     case "list_column": {
       let raw = clone.contents;
@@ -961,7 +962,21 @@ const normalizeLayoutCandidate = (candidate, ctx) => {
     normalized = convertForeignLayout(candidate, ctx);
   }
   if (!normalized) return null;
-  const layout = Array.isArray(normalized) ? { above: normalized } : normalized;
+  let layout = Array.isArray(normalized) ? { above: normalized } : normalized;
+
+  // For listcolumns mode: if the LLM wrapped the list in a stack, unwrap it
+  if (
+    ctx.mode === "listcolumns" &&
+    layout.type === "stack" &&
+    Array.isArray(layout.above)
+  ) {
+    const listChild = layout.above.find((c) => c?.list_columns);
+    if (listChild) {
+      const { type: _t, ...rest } = listChild;
+      layout = rest;
+    }
+  }
+
   return sanitizeNoHtmlSegments(layout);
 };
 
@@ -1000,6 +1015,11 @@ const buildPromptText = (userPrompt, ctx, schema) => {
       schema
     )}`
   );
+  parts.push(
+    `TOOL CALL REQUIRED: If the layout you are about to generate contains any view_link or embedded view (type "view") segment, ` +
+      `you MUST call get_relation_paths with all required source_table/target_view pairs BEFORE returning JSON. ` +
+      `Do NOT guess or omit the "relation" field — return the tool call first and use the result in the layout.`
+  );
   parts.push(
     `Based on the schema above, process the following user request and generate the layout JSON. Reminder: ONLY output valid JSON starting with { and ending with }, no markdown fences.\nUser request:\n"${userPrompt}"`
   );
@@ -1220,7 +1240,6 @@ const buildBracketObject = (node) => {
   return obj;
 };
 
-
 const buildContext = async (mode, tableName) => {
   const normalizedMode = (mode || "show").toLowerCase();
   const ctx = {
@@ -1286,9 +1305,16 @@ const buildContext = async (mode, tableName) => {
     if (!fieldviews.length && String(typeName).startsWith("Key")) {
       fieldviews = ["select", "show"];
     }
+    // File fields store their fieldviews in state.fileviews, not on the type object
+    let fileFvDefs = {};
+    if (String(typeName) === "File") {
+      fileFvDefs = getState().fileviews || {};
+      fieldviews = Object.keys(fileFvDefs);
+    }
     // editFieldviews: only fieldviews where isEdit is not explicitly false
+    const effectiveFvDefs = String(typeName) === "File" ? fileFvDefs : fvDefs;
     const editFieldviews = fieldviews.filter(
-      (fv) => fvDefs[fv]?.isEdit !== false
+      (fv) => effectiveFvDefs[fv]?.isEdit !== false
     );
 
     const isPkName =
@@ -1400,16 +1426,19 @@ const buildErrorLayout = ({ message, mode, table }) => {
   };
 };
 
-const GET_RELATION_PATHS_TOOL = { type: "function", function: GET_RELATION_PATHS_FUNCTION };
+const GET_RELATION_PATHS_TOOL = {
+  type: "function",
+  function: GET_RELATION_PATHS_FUNCTION,
+};
 
 /**
- * Run the LLM giving it one opportunity to call get_relation_paths before
- * producing the final layout JSON. Returns the final text response.
+ * Run the LLM allowing up to MAX_TOOL_ROUNDS get_relation_paths calls (depth
+ * escalation: 2 → 4 → 6) before producing the final layout JSON.
  */
+const MAX_TOOL_ROUNDS = 4;
 const runWithRelationTools = async (llm, mainPrompt, opts) => {
   const llm_add_message = getState().functions.llm_add_message;
 
-  // Local chat copy with the main prompt pre-loaded so all iterations see it.
   const runChat = Array.isArray(opts.chat) ? [...opts.chat] : [];
   runChat.push({ role: "user", content: mainPrompt });
 
@@ -1418,35 +1447,54 @@ const runWithRelationTools = async (llm, mainPrompt, opts) => {
   delete toolOpts.response_format;
   delete toolOpts.chat;
 
-  // Call 1: model either returns JSON directly or calls get_relation_paths.
-  const raw = await llm.run(null, { ...toolOpts, chat: runChat });
-  if (!raw?.hasToolCalls) {
-    return typeof raw === "string" ? raw : raw?.content ?? "";
-  }
+  const schemaData = await build_schema_data();
 
-  // Append the assistant message so call 2 has full context.
-  if (raw.ai_sdk && Array.isArray(raw.messages)) {
-    raw.messages.filter((m) => m.role === "assistant").forEach((m) => runChat.push(m));
-  } else if (raw.tool_calls) {
-    runChat.push({ role: "assistant", content: raw.content || null, tool_calls: raw.tool_calls });
-  }
+  for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+    const raw = await llm.run(null, { ...toolOpts, chat: runChat });
 
-  // Resolve the tool call(s) and push results.
-  const schemaData = await build_schema_data();
-  for (const tc of raw.getToolCalls()) {
-    let resultText;
-    if (tc.tool_name === "get_relation_paths") {
-      const sections = getRelationPathsForPairs(tc.input.pairs || [], schemaData);
-      resultText =
-        sections.join("\n\n") +
-        `\n\nSet the "relation" property to one of the strings listed above for each view_link.`;
-    } else {
-      resultText = `Unknown tool: ${tc.tool_name}`;
+    if (!raw?.hasToolCalls) {
+      return typeof raw === "string" ? raw : raw?.content ?? "";
+    }
+
+    // Append the assistant message so the next round has full context.
+    if (raw.ai_sdk && Array.isArray(raw.messages)) {
+      raw.messages
+        .filter((m) => m.role === "assistant")
+        .forEach((m) => runChat.push(m));
+    } else if (raw.tool_calls) {
+      runChat.push({
+        role: "assistant",
+        content: raw.content || null,
+        tool_calls: raw.tool_calls,
+      });
+    }
+
+    for (const tc of raw.getToolCalls()) {
+      let resultText;
+      if (tc.tool_name === "get_relation_paths") {
+        const maxDepth = tc.input.max_depth ?? 2;
+        const sections = getRelationPathsForPairs(
+          tc.input.pairs || [],
+          schemaData,
+          maxDepth
+        );
+        resultText =
+          sections.join("\n\n") +
+          `\n\nFor each pair above: analyse whether the listed paths include a suitable one for the intended relation type (ChildList, ParentShow, Own, etc.). ` +
+          `If a suitable path exists, set the "relation" property to the chosen path string for all types including Own. ` +
+          `If no suitable path exists for a pair (no paths listed, or none match the intended type), call get_relation_paths again with a higher max_depth (4, then 6). ` +
+          `Do not escalate just because multiple paths are listed — only escalate when none is appropriate.`;
+      } else {
+        resultText = `Unknown tool: ${tc.tool_name}`;
+      }
+      await llm_add_message.run("tool_response", resultText, {
+        chat: runChat,
+        tool_call: tc,
+      });
     }
-    await llm_add_message.run("tool_response", resultText, { chat: runChat, tool_call: tc });
   }
 
-  // Call 2: model has relation paths, now generates the layout JSON.
+  // Exhausted tool rounds — force final JSON answer.
   const final = await llm.run(null, { ...opts, chat: runChat });
   return typeof final === "string" ? final : final?.content ?? "";
 };
@@ -1564,6 +1612,7 @@ module.exports = {
   },
   isAsync: true,
   description: "Generate a builder layout",
+  hidden: true,
   arguments: [
     { name: "prompt", type: "String" },
     { name: "mode", type: "String" },

package/builder-schema.js

@@ -327,7 +327,13 @@ const buildBuilderSchema = ({ mode, ctx }) => {
   const actionDef = buildSegmentDef({
     type: "action",
     description: "Action button segment.",
+    required: ["rndid"],
     properties: {
+      rndid: {
+        type: "string",
+        description:
+          "Unique short identifier for this action (e.g. 'act1', 'del2'). REQUIRED — omitting it causes a server crash.",
+      },
       action_name: defs.action_name_enum
         ? { $ref: "#/$defs/action_name_enum", description: "Action name." }
         : { type: "string", description: "Action name." },

package/copilot-as-agent.js

@@ -62,6 +62,7 @@ const get_agent_view = () => {
     min_role: 1,
     configuration: {
       agent_action,
+      show_prev_runs: true,
       viewname,
     },
   });

package/index.js

@@ -18,7 +18,6 @@ module.exports = {
   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"),

package/js-code-gen.js

@@ -57,6 +57,7 @@ module.exports = {
   },
   isAsync: true,
   description: "Generate JavaScript code for an action",
+  hidden: true,
   arguments: [
     { name: "description", type: "String" },
     { name: "existing_code", type: "String" },

package/package.json

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

package/relation-paths.js

@@ -36,66 +36,72 @@ const { RelationsFinder, RelationType } = require("@saltcorn/common-code");
 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).
+Every view_link and embedded view segment requires two fields:
+- \`view\`: the view name (plain string, e.g. \`"packing_items_list"\`)
+- \`relation\`: a dot-separated path string (e.g. \`".trips.packing_items$trip_id"\`)
 
----
+**Always use this format. Never generate anything else.**
 
-### 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"\`
+### Relation path format
 
-**Path string format:** \`.sourcetable.segment1.segment2...\`
+\`.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\`
+- **Outbound FK** (to a parent): FK field name alone — e.g. \`trip_id\`
+- **Inbound FK** (child rows): \`childtable$fkfield\` — e.g. \`packing_items$trip_id\`
+- **Same table** (no FK traversal): just the source table, no segments — e.g. \`".invoice_line_items"\`
 
 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 |
+| relation string | meaning |
+|---|---|
+| \`.invoice_line_items\` | same-table link (no FK traversal) |
+| \`.trips.packing_items$trip_id\` | all packing_items for a trip |
+| \`.packing_items.trip_id\` | the trip that owns a packing_item |
+| \`.artists.artist_plays_on_album$artist.album\` | albums via join table |
+| \`.users.orders$user_id.order_lines$order_id\` | multi-level |
 
 ---
 
-### Legacy format (you may encounter this in existing configs — do not generate it)
+### Legacy format — read-only, never generate
 
-The type and path are encoded together inside the \`view\` field as a colon-prefixed string.
-There is no separate \`relation\` field.
+Any \`view\` field value that contains a colon (e.g. \`"ChildList:trips_list.packing_items.trip_id"\`,
+\`"Own:viewname"\`, \`"ParentShow:viewname.table.fkfield"\`) is legacy. You may encounter it in
+existing configs. Parse it to understand the relation, then always write back in the new format.
 
-| legacy view field | equivalent new relation |
+| legacy view field | new format equivalent |
 |---|---|
-| \`"Own:viewname"\` | \`view: "viewname"\`, no relation |
+| \`"Own:viewname"\` | \`relation: ".sourcetable"\` |
+| \`"Independent:viewname"\` | no \`relation\` field needed |
 | \`"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.
+Call it **once** with all source_table/target_view pairs you need. The tool always returns new-format
+path strings — use them as the \`relation\` field directly.
 
-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).
+**Depth escalation:** Start with \`max_depth=2\`. After receiving results, analyse each pair: does the
+result contain a path that matches the intended relation type? If yes, use it. If a pair has no
+suitable path (no paths at all, or none of the right type), call again with \`max_depth=4\`, then
+\`max_depth=6\` if still none. Do not escalate just because multiple paths are listed.
+
+Selecting among returned paths:
+- **ChildList** — target view shows multiple rows belonging to the current row.
+- **ParentShow** — target view shows the single parent the current row belongs to.
 - **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.
+- **Own** — same table, no FK traversal. Relation string is just \`.sourcetable\`.
+- If multiple paths of the same type exist, pick the one whose FK field name best matches 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)";
+    return "Own – source and target are the same table. Use this relation string as-is (no extra segments after the table name).";
   if (type === RelationType.INDEPENDENT)
     return "Independent – no FK relationship exists";
   if (type === RelationType.PARENT_SHOW)
@@ -113,10 +119,19 @@ const typeToLabel = (type) => {
  * @param {{ tables, views }} schemaData  pre-fetched via build_schema_data()
  * @returns {Array<Relation>}  raw Relation objects from RelationsFinder
  */
-function getRelationPaths(sourceTableName, targetViewName, schemaData) {
+function getRelationPaths(
+  sourceTableName,
+  targetViewName,
+  schemaData,
+  maxDepth = 6
+) {
   if (!schemaData) return [];
   try {
-    const finder = new RelationsFinder(schemaData.tables, schemaData.views, 6);
+    const finder = new RelationsFinder(
+      schemaData.tables,
+      schemaData.views,
+      maxDepth
+    );
     return finder.findRelations(sourceTableName, targetViewName, []);
   } catch {
     return [];
@@ -130,13 +145,22 @@ function getRelationPaths(sourceTableName, targetViewName, schemaData) {
  * @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" })
+function getRelationPathsForPairs(pairs, schemaData, maxDepth = 6) {
+  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,
+    maxDepth
   );
-  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);
+    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`,
@@ -198,8 +222,11 @@ 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.",
+    "Call this before setting any 'relation' property on view_link columns or embedded view segments. " +
+    "Always start with max_depth=2 to keep the result compact. " +
+    "After receiving the results, analyse whether each pair has a suitable path for its intended relation type. " +
+    "If a pair has no suitable path, call again with max_depth=4, then max_depth=6 if still none. " +
+    "Stop as soon as every pair has a suitable path.",
   parameters: {
     type: "object",
     required: ["pairs"],
@@ -223,6 +250,12 @@ const GET_RELATION_PATHS_FUNCTION = {
           },
         },
       },
+      max_depth: {
+        type: "integer",
+        description:
+          "Maximum join depth to search. Start with 2. Escalate to 4, then 6, only if a pair has no suitable path in the current results — not just because paths exist, but because none match the intended relation type.",
+        default: 2,
+      },
     },
   },
 };

package/standard-prompt.js

@@ -73,6 +73,7 @@ ${ds.join("\n")}`);
   },
   isAsync: true,
   description: "Return a standard prompt for writing code",
+  hidden: true,
   arguments: [
     {
       name: "options",

package/user-copilot.js

@@ -933,5 +933,7 @@ module.exports = {
   get_state_fields,
   tableless: true,
   run,
+  deprecated: true,
+  description: "Use Agents from the agent module instead",
   routes: { interact, delprevrun },
 };

package/workflow-gen.js

@@ -41,5 +41,6 @@ module.exports = {
   },
   isAsync: true,
   description: "Generate a workflow",
+  hidden: true,
   arguments: [{ name: "description", type: "String" }],
 };

package/app-constructor/prompts.js

@@ -1,120 +0,0 @@
-const saltcorn_description = `This application will be implemented in Saltcorn, a database application development
-environment. 
-
-Saltcorn applications contain the following entity types:
-
-* Tables: These are relational database tables and consists of fields of specified types and rows 
-with a value for each field. Fields optionally can be required and/or unique. Every field has a name, 
-which is a an identifier that is balid in both JavaScript and SQL, and a label, which is any short 
-user-friendly string. Every table has a primary key
-(composite primary keys are not supported) which by default is an auto-incrementing integer with 
-name \`id\` and label ID. Fields can also be of Key type (foreign key) referencing a primary key 
-in another table, or its own table for a self-join. Tables can have 
-calculated fields, which can be stored or non-stored. Both stored and non-stored fields are 
-defined by a JavaScript expression, but only stored fields can reference other tables with join 
-fields and aggregations.
-
-* Views: Views are elementary user interfaces into a database table. A view is defined by applying a 
-view template (also sometime called a view pattern, the two are synonymous) to a table with a certain
-configuration. The view template defines the fundamental relationship between the UI and the table. For
-instance, the Show view template displays a single database row, the Edit view template is a form that 
-can create a new row or edit an existing row, the List view template displays multiple rows in a grid. 
-Views can embed views, for instance Show can embed another row through a Key field relationship, or 
-some views are defined by an underlying view. For instance, the Feed view repeats an underlying view 
-for multiple tables. New viewtemplates are provided by plugin modules.
-
-* Triggers: Triggers connect elementary actions (provided by plugin modules) to either a button in the
-user interface, or a periodic (hourly, daily etc) or table (for instance insert on specifc table) event.
-The elementary action each has a number of configuration fields that must be filled in after connecting
-the action to an event, table or button.
-
-* Page: A page has static content but can also embed views for synamic content. Pages can be either 
-defined by a Saltcorn layout, for pages that can be edited with drag and drop, or by HTML for more 
-flexible graphic designs. HTML pages should be used for landing pages.
-
-* Plugin modules: plugin modules can supply new field types, view templates or actions. Before they can be used,
-they need to be installed before they can be used. A plugin may also have a configuration that sets options
-for that plugin. Layout themes is Saltcorn are plugin modules.
-`;
-
-const existing_tables_list = (tables) => {
-  const tableLines = [];
-  tables.forEach((table) => {
-    const fieldLines = table.fields.map(
-      (f) =>
-        `  * ${f.name} with type: ${f.pretty_type}.${
-          f.description ? ` ${f.description}` : ""
-        }`
-    );
-    tableLines.push(
-      `${table.name}${
-        table.description ? `: ${table.description}.` : "."
-      } Contains the following fields:\n${fieldLines.join("\n")}`
-    );
-  });
-  return `The database already contains the following tables: 
-
-${tableLines.join("\n\n")}`;
-};
-
-const existing_entities_list = ({ views, triggers, pages, tableById = {} }) => {
-  const sections = [];
-  if (views.length)
-    sections.push(
-      `The following views are already implemented — do NOT plan tasks to create them:\n` +
-        views
-          .map((v) => {
-            const tablePart =
-              v.table?.name ||
-              (v.table_id && tableById[v.table_id]) ||
-              v.exttable_name;
-            return `- ${v.name} (${v.viewtemplate}${
-              tablePart ? ` on ${tablePart}` : ""
-            })`;
-          })
-          .join("\n")
-    );
-  if (triggers.length)
-    sections.push(
-      `The following triggers are already implemented — do NOT plan tasks to create them:\n` +
-        triggers
-          .map(
-            (t) =>
-              `- ${t.name} (${t.action}${
-                t.when_trigger ? `, ${t.when_trigger}` : ""
-              })`
-          )
-          .join("\n")
-    );
-  if (pages.length)
-    sections.push(
-      `The following pages are already implemented — do NOT plan tasks to create them:\n` +
-        pages.map((p) => `- ${p.name}`).join("\n")
-    );
-  return sections.join("\n\n");
-};
-
-const available_plugins_list = (storePlugins, installedNames) => {
-  const uninstalled = storePlugins.filter((p) => !installedNames.has(p.name));
-  if (!uninstalled.length) return "";
-  const lines = uninstalled.map((p) => {
-    let line = `### ${p.name}`;
-    if (p.description) line += `\n${p.description}`;
-    if (p.contents) line += `\n${p.contents}`;
-    return line;
-  });
-  return (
-    `The following plugins are available in the Saltcorn store but not yet installed. ` +
-    `If a task requires functionality provided by one of these plugins (e.g. a specific view template, field type, or action), ` +
-    `include an explicit "Install plugin <name>" task before it with the exact plugin name as listed here. ` +
-    `The executor will use that name directly without needing to look it up.\n\n` +
-    lines.join("\n\n")
-  );
-};
-
-module.exports = {
-  saltcorn_description,
-  existing_tables_list,
-  existing_entities_list,
-  available_plugins_list,
-};