@saltcorn/copilot 0.1.1 → 0.3.0

package/action-builder.js

@@ -128,10 +128,14 @@ const runPost = async (
   form.hasErrors = false;
   form.errors = {};
 
-  const fullPrompt = await getPromptFromTemplate(
+  const partPrompt = await getPromptFromTemplate(
     "action-builder.txt",
     form.values.prompt
   );
+  const fullPrompt =
+    partPrompt +
+    "\n\nWrite the JavaScript code to implement the following functionality:\n\n" +
+    form.values.prompt;
 
   const completion = await getCompletion("JavaScript", fullPrompt);
 

package/actions/generate-js-action.js

@@ -0,0 +1,108 @@
+const { getState } = require("@saltcorn/data/db/state");
+const WorkflowStep = require("@saltcorn/data/models/workflow_step");
+const Trigger = require("@saltcorn/data/models/trigger");
+const Table = require("@saltcorn/data/models/table");
+const Field = require("@saltcorn/data/models/field");
+const { apply, removeAllWhiteSpace } = require("@saltcorn/data/utils");
+const { getActionConfigFields } = require("@saltcorn/data/plugin-helper");
+const { a, pre, script, div, code } = require("@saltcorn/markup/tags");
+const { fieldProperties, getPromptFromTemplate } = require("../common");
+
+class GenerateJsAction {
+  static title = "Generate JavaScript Action";
+  static function_name = "generate_js_action";
+  static description = "Generate Javascript Action";
+
+  static async json_schema() {
+    return {
+      type: "object",
+      required: ["action_javascript_code", "action_name"],
+      properties: {
+        action_javascript_code: {
+          description: "JavaScript code that constitutes the action",
+          type: "string",
+        },
+        action_name: {
+          description:
+            "A human-readable label for the action. Can include spaces and mixed case, should be 1-5 words.",
+          type: "string",
+        },
+        action_description: {
+          description: "A description of the purpose of the action.",
+          type: "string",
+        },
+        when_trigger: {
+          description:
+            "When the action should trigger. Optional, leave blank if unspecified or workflow will be run on button click",
+          type: "string",
+          enum: ["Insert", "Delete", "Update", "Daily", "Hourly", "Weekly"],
+        },
+        trigger_table: {
+          description:
+            "If the action trigger is Insert, Delete or Update, the name of the table that triggers the workflow",
+          type: "string",
+        },
+      },
+    };
+  }
+  static async system_prompt() {
+    const partPrompt = await getPromptFromTemplate("action-builder.txt", "");
+    return (
+      `Use the generate_js_action to generate actions based on JavaScript code. ` +
+      partPrompt
+    );
+  }
+  static render_html({
+    action_javascript_code,
+    action_name,
+    action_description,
+    when_trigger,
+    trigger_table,
+  }) {
+    return (
+      div({class: "mb-3"},
+        `${action_name}${when_trigger ? `: ${when_trigger}` : ""}${
+          trigger_table ? ` on ${trigger_table}` : ""
+        }`
+      ) + pre(code(action_javascript_code))
+    );
+  }
+  static async execute(
+    {
+      action_javascript_code,
+      action_name,
+      action_description,
+      when_trigger,
+      trigger_table,
+    },
+    req
+  ) {
+    let table_id;
+    if (trigger_table) {
+      const table = Table.findOne({ name: trigger_table });
+      if (!table) return { postExec: `Table not found: ${trigger_table}` };
+      table_id = table.id;
+    }
+    const trigger = await Trigger.create({
+      name: action_name,
+      when_trigger: when_trigger || "Never",
+      table_id,
+      action: "run_js_code",
+      configuration: {code: action_javascript_code},
+    });
+    Trigger.emitEvent("AppChange", `Trigger ${trigger.name}`, req?.user, {
+      entity_type: "Trigger",
+      entity_name: trigger.name,
+    });
+    return {
+      postExec:
+        "Action created. " +
+        a(
+          { target: "_blank", href: `/actions/configure/${trigger.id}` },
+          "Configure action."
+        ),
+    };
+  }
+}
+
+module.exports = GenerateJsAction;

package/actions/generate-tables.js

@@ -0,0 +1,259 @@
+const { getState } = require("@saltcorn/data/db/state");
+const WorkflowStep = require("@saltcorn/data/models/workflow_step");
+const Trigger = require("@saltcorn/data/models/trigger");
+const Table = require("@saltcorn/data/models/table");
+const Field = require("@saltcorn/data/models/field");
+const { apply, removeAllWhiteSpace } = require("@saltcorn/data/utils");
+const { getActionConfigFields } = require("@saltcorn/data/plugin-helper");
+const { a, pre, script, div } = require("@saltcorn/markup/tags");
+const { fieldProperties } = require("../common");
+
+class GenerateTables {
+  static title = "Generate Tables";
+  static function_name = "generate_tables";
+  static description = "Generate database tables";
+
+  static async json_schema() {
+    const types = Object.values(getState().types);
+    const fieldTypeCfg = types.map((ty) => {
+      const properties = {
+        data_type: { const: ty.name },
+      };
+      const attrs = apply(ty.attributes, {}) || [];
+      attrs.forEach((a) => {
+        properties[a.name] = {
+          description:
+            a.copilot_description ||
+            `${a.label}.${a.sublabel ? ` ${a.sublabel}` : ""}`,
+          ...fieldProperties(a),
+        };
+      });
+      return {
+        type: "object",
+        description: ty.copilot_description || ty.description,
+        properties,
+      };
+    });
+    fieldTypeCfg.push({
+      type: "object",
+      description:
+        "A foreign key to a different table. This will reference the primary key on another table.",
+      properties: {
+        data_type: { const: "ForeignKey" },
+        reference_table: {
+          type: "string",
+          description: "Name of the table being referenced",
+        },
+      },
+    });
+    fieldTypeCfg.push({
+      type: "object",
+      description:
+        "A reference (file path) to a file on disk. This can be used for example to hold images or documents",
+      properties: {
+        data_type: { const: "File" },
+      },
+    });
+    return {
+      type: "object",
+      required: ["tables"],
+      properties: {
+        tables: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["table_name", "fields"],
+            properties: {
+              table_name: {
+                type: "string",
+                description: "The name of the table",
+              },
+              fields: {
+                type: "array",
+                items: {
+                  type: "object",
+                  required: [
+                    "name",
+                    "label",
+                    "type_and_configuration",
+                    "importance",
+                  ],
+                  properties: {
+                    name: {
+                      type: "string",
+                      description:
+                        "The field name. Must be a valid identifier in both SQL and JavaScript, all lower case, snake_case (underscore instead of spaces)",
+                    },
+                    label: {
+                      type: "string",
+                      description:
+                        "A human-readable label for the field. Should be short, 1-4 words, can have spaces and mixed case.",
+                    },
+                    not_null: {
+                      type: "boolean",
+                      description:
+                        "A value is required and the field will be NOT NULL in the database",
+                    },
+                    unique: {
+                      type: "boolean",
+                      description:
+                        "The value is unique - different rows must have different values for this field",
+                    },
+                    type_and_configuration: { anyOf: fieldTypeCfg },
+                    importance: {
+                      type: "number",
+                      description:
+                        "How important is this field if only some fields can be displayed to the user. From 1 (least important) to 10 (most important).",
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    };
+  }
+
+  static async system_prompt() {
+    const tableLines = [];
+    const tables = await Table.find({});
+    tables.forEach((table) => {
+      const fieldLines = table.fields.map(
+        (f) =>
+          `  * ${f.name} with type: ${f.pretty_type.replace(
+            "Key to",
+            "ForeignKey referencing"
+          )}.${f.description ? ` ${f.description}` : ""}`
+      );
+      tableLines.push(
+        `${table.name}${
+          table.description ? `: ${table.description}.` : "."
+        } Contains the following fields:\n${fieldLines.join("\n")}`
+      );
+    });
+    return `Use the generate_tables tool to construct one or more database tables.
+
+    Do not call this tool more than once. It should only be called once. If you are
+    building more than one table, use one call to the generate_tables tool to build all the 
+    tables.
+
+    The argument to generate_tables is an array of tables, each with an array of fields. You do not
+    need to specify a primary key, a primary key called id with autoincrementing integers is
+    autmatically generated. 
+
+    The database already contains the following tables: 
+
+    ${tableLines.join("\n\n")}
+
+    `;
+  }
+  static render_html({ tables }) {
+    const sctables = this.process_tables(tables);
+    const mmdia = buildMermaidMarkup(sctables);
+    return (
+      pre({ class: "mermaid" }, mmdia) +
+      script(`mermaid.run({querySelector: 'pre.mermaid'});`)
+    );
+  }
+
+  static async execute({ tables }, req) {
+    const sctables = this.process_tables(tables);
+    for (const table of sctables) await Table.create(table.name);
+    for (const table of sctables) {
+      for (const field of table.fields) {
+        field.table = Table.findOne({ name: table.name });
+        await Field.create(field);
+      }
+    }
+    Trigger.emitEvent("AppChange", `Tables created`, req?.user, {
+      entity_type: "Table",
+      entity_names: sctables.map((t) => t.name),
+    });
+  }
+
+  static process_tables(tables) {
+    return tables.map((table) => {
+      return new Table({
+        name: table.table_name,
+        fields: table.fields.map((f) => {
+          const { data_type, reference_table, ...attributes } =
+            f.type_and_configuration;
+          let type = data_type;
+          const scattributes = { ...attributes, importance: f.importance };
+          if (data_type === "ForeignKey") {
+            type = `Key to ${reference_table}`;
+            let refTableHere = tables.find(
+              (t) => t.table_name === reference_table
+            );
+            if (refTableHere) {
+              const strFields = refTableHere.fields.filter(
+                (f) => f.type_and_configuration.data_type === "String"
+              );
+              if (strFields.length) {
+                const maxImp = strFields.reduce(function (prev, current) {
+                  return prev && prev.importance > current.importance
+                    ? prev
+                    : current;
+                });
+                if (maxImp) scattributes.summary_field = maxImp.name;
+              }
+            } else if (reference_table === "users") {
+              scattributes.summary_field = "email";
+            }
+          }
+
+          return {
+            ...f,
+            type,
+            required: f.not_null,
+            attributes: scattributes,
+          };
+        }),
+      });
+    });
+  }
+}
+
+const EOL = "\n";
+const indentString = (str, indent) => `${" ".repeat(indent)}${str}`;
+
+const srcCardinality = (field) => (field.required ? "||" : "|o");
+
+const buildTableMarkup = (table) => {
+  const fields = table.getFields();
+  const members = fields
+    // .filter((f) => !f.reftable_name)
+    .map((f) =>
+      indentString(`${removeAllWhiteSpace(f.type_name)} ${f.name}`, 6)
+    )
+    .join(EOL);
+  const keys = table
+    .getForeignKeys()
+    .map((f) =>
+      indentString(
+        `"${table.name}"${srcCardinality(f)}--|| "${f.reftable_name}" : "${
+          f.name
+        }"`,
+        2
+      )
+    )
+    .join(EOL);
+  return `${keys}
+  "${table.name}" {${EOL}${members}${EOL}  }`;
+};
+
+const buildMermaidMarkup = (tables) => {
+  const lines = tables.map((table) => buildTableMarkup(table)).join(EOL);
+  return `${indentString("erDiagram", 2)}${EOL}${lines}`;
+};
+
+module.exports = GenerateTables;
+
+/* todo
+
+- tag
+- generate descriptions
+- generate views
+
+*/

package/actions/generate-workflow.js

@@ -0,0 +1,320 @@
+const { getState } = require("@saltcorn/data/db/state");
+const WorkflowStep = require("@saltcorn/data/models/workflow_step");
+const Trigger = require("@saltcorn/data/models/trigger");
+const Table = require("@saltcorn/data/models/table");
+const { getActionConfigFields } = require("@saltcorn/data/plugin-helper");
+const { a, pre, script, div } = require("@saltcorn/markup/tags");
+const { fieldProperties } = require("../common");
+
+const steps = async () => {
+  const actionExplainers = WorkflowStep.builtInActionExplainers();
+  const actionFields = await WorkflowStep.builtInActionConfigFields();
+
+  let stateActions = getState().actions;
+  const stateActionList = Object.entries(stateActions).filter(
+    ([k, v]) => !v.disableInWorkflow
+  );
+
+  const stepTypeAndCfg = Object.keys(actionExplainers).map((actionName) => {
+    const properties = { step_type: { const: actionName } };
+    const myFields = actionFields.filter(
+      (f) => f.showIf?.wf_action_name === actionName
+    );
+    const required = ["step_type"];
+    myFields.forEach((f) => {
+      if (f.required) required.push(f.name);
+      properties[f.name] = {
+        description: f.sublabel || f.label,
+        ...fieldProperties(f),
+      };
+    });
+    return {
+      type: "object",
+      description: actionExplainers[actionName],
+      properties,
+      required,
+    };
+  });
+  for (const [actionName, action] of stateActionList) {
+    try {
+      const properties = { step_type: { const: actionName } };
+      const cfgFields = await getActionConfigFields(action, null, {
+        mode: "workflow",
+        copilot: true,
+      });
+      const required = ["step_type"];
+      cfgFields.forEach((f) => {
+        if (f.input_type === "section_header") return;
+        if (f.required) required.push(f.name);
+        properties[f.name] = {
+          description: f.sublabel || f.label,
+          ...fieldProperties(f),
+        };
+      });
+      stepTypeAndCfg.push({
+        type: "object",
+        description:
+          actionExplainers[actionName] ||
+          `${actionName}.${action.description ? ` ${action.description}` : ""}`,
+        properties,
+        required,
+      });
+    } catch (e) {
+      //ignore
+    }
+  }
+  const triggers = Trigger.find({
+    when_trigger: { or: ["API call", "Never"] },
+  }).filter((tr) => tr.description && tr.name && tr !== "Workflow");
+  //TODO workflows
+  for (const trigger of triggers) {
+    const properties = {
+      step_type: { const: trigger.name },
+    };
+    if (trigger.table_id) {
+      const table = Table.findOne({ id: trigger.table_id });
+      const fieldSpecs = [];
+      table.fields.forEach((f) => {
+        // TODO fkeys dereferenced.
+        fieldSpecs.push(`${f.name} with ${f.pretty_type} type`);
+      });
+      properties.row_expr = {
+        type: "string",
+        description: `JavaScript expression for the input to the action. This should be an expression for an object, with the following field name and types: ${fieldSpecs.join(
+          "; "
+        )}.`,
+      };
+    }
+    const required = ["step_type"];
+    stepTypeAndCfg.push({
+      type: "object",
+      description: `${trigger.name}: ${trigger.description}`,
+      properties,
+      required,
+    });
+  }
+  const properties = {
+    step_name: {
+      description: "The name of this step as a valid Javascript identifier",
+      type: "string",
+    },
+    only_if: {
+      description:
+        "Optional JavaScript expression based on the context. If given, the chosen action will only be executed if evaluates to true",
+      type: "string",
+    },
+    /*step_type: {
+        description: "The type of workflow step",
+        type: "string",
+        enum: Object.keys(actionExplainers),
+      },*/
+    next_step: {
+      description:
+        "The next step in the workflow, as a JavaScript expression based on the context.",
+      type: "string",
+    },
+    step_configuration: { anyOf: stepTypeAndCfg },
+  };
+  return {
+    type: "array",
+    items: {
+      type: "object",
+      properties,
+    },
+  };
+};
+
+class GenerateWorkflow {
+  static title = "Generate Workflow";
+  static function_name = "generate_workflow";
+  static description = "Generate the steps in a workflow";
+
+  static async json_schema() {
+    return {
+      type: "object",
+      properties: {
+        workflow_steps: await steps(),
+        workflow_name: {
+          description:
+            "The name of the workflow. Can include spaces and mixed case, should be 1-5 words.",
+          type: "string",
+        },
+        when_trigger: {
+          description:
+            "When the workflow should trigger. Optional, leave blank if unspecified or workflow will be run on button click",
+          type: "string",
+          enum: ["Insert", "Delete", "Update", "Daily", "Hourly", "Weekly"],
+        },
+        trigger_table: {
+          description:
+            "If the workflow trigger is Insert, Delete or Update, the name of the table that triggers the workflow",
+          type: "string",
+        },
+      },
+    };
+  }
+
+  static async system_prompt() {
+    const actionExplainers = WorkflowStep.builtInActionExplainers();
+    let stateActions = getState().actions;
+    const stateActionList = Object.entries(stateActions).filter(
+      ([k, v]) => !v.disableInWorkflow
+    );
+
+    return `Use the generate_workflow tool to construct computational workflows according to specifications. You must create 
+  the workflow by calling the generate_workflow tool, with the step required to implement the specification.
+  
+  The steps are specified as JSON objects. Each step has a name, specified in the step_name key in the JSON object. 
+  The step name should be a valid JavaScript identifier.
+  
+  Each run of the workflow is executed in the presence of a context, which is a JavaScript object that individual
+  steps can read values from and write values to. This context is a state that is persisted on disk for each workflow 
+  run. 
+  
+  Each step can have a next_step key which is the name of the next step, or a JavaScript expression which evaluates 
+  to the name of the next step based on the context. In the evaluation of the next step, each value in the context is 
+  in scope and can be addressed directly. Identifiers for the step names are also in scope, the name of the next step 
+  can be used directly without enclosing it in quotes to form a string. 
+  
+  For example, if the context contains a value x which is an integer and you have steps named "too_low" and "too_high",
+  and you would like the next step to be too_low if x is less than 10 and too_high otherwise,
+  use this as the next_step expression: x<10 ? too_low : too_high
+  
+  If the next_step is omitted then the workflow terminates.
+  
+  Each step has a step_configuration object which contains the step type and the specific parameters of 
+  that step type. You should specify the step type in the step_type subfield of the step_configuration
+  field. The available step types are:
+  
+  ${Object.entries(actionExplainers)
+    .map(([k, v]) => `* ${k}: ${v}`)
+    .join("\n")}
+  ${stateActionList
+    .map(([k, v]) => `* ${k}: ${v.description || ""}`)
+    .join("\n")}
+  
+  Most of them are are explained by their parameter descriptions. Here are some additional information for some
+  step types:
+  
+  run_js_code: if the step_type is "run_js_code" then the step object should include the JavaScript code to be executed in the "code"
+  key. You can use await in the code if you need to run asynchronous code. The values in the context are directly in scope and can be accessed using their name. In addition, the variable 
+  "context" is also in scope and can be used to address the context as a whole. To write values to the context, return an
+  object. The values in this object will be written into the current context. If a value already exists in the context 
+  it will be overwritten. For example, If the context contains values x and y which are numbers and you would like to push
+  the value "sum" which is the sum of x and y, then use this as the code: return {sum: x+y}. You cannot set the next step in the 
+  return object or by returning a string from a run_js_code step, this will not work. To set the next step from a code action, always use the next_step property of the step object.
+  This expression for the next step can depend on value pushed to the context (by the return object in the code) as these values are in scope.  
+  
+  ForLoop: ForLoop steps loop over an array which is specified by the array_expression JavaScript expression. Execution of the workflow steps is temporarily diverted to another set
+  of steps, starting from the step specified by the loop_body_inital_step value, and runs until it encounters a
+  step with nothing specified for next_step at which point the next iteration (over the next item in the array) is started. When all items have
+  been iterated over, the for loop is complete and execution continues with the next_step of the ForLoop step. During each iteration 
+  of the loop, the current array item is temporarily set to a variable in the context specified by the item_variable variable. The steps between
+  in the loop body can access this current array items in the context by the context item_variable name.
+  When all items have been iterated, the for loop will continue from the step indicated by its next_step. 
+  
+  llm_generate: use a llm_generate step to consult an artificial intelligence language processor to ask a question in natural language in which the answer is given in natural language. The answer is based on a 
+  question, specified as a string in the step conmfiguration "prompt_template" key in which you can user interpolation ({{ }}) to access context variables. Running the step will provide an answer by a 
+  highly capable artificial intelligence processor who however does not have in-depth knowledge of the subject matter or any case specifics at hand - you
+  must provide all these details in the question string, which should concatenate multiple background documents before asking the
+  actual question. You must also provide a variable name (in the answer_field key in the step definition) where the answer
+  will be pushed to the context as a string. If you specificy a variable name in chat_history_field, the invocation of subsequent llm_generate
+  steps in the same workflow will contain the interaction history of previous invocations, so you don't have to repeat information in the prompt and can
+  maintain a conversational interaction.
+  
+  llm_generate_json: use llm_generate_json steps to extract structured information from text. llm_generate_json uses natural language processing to read a document, 
+  and to generate JSON objects with specified fields. A llm_generate_json step requires four settings in the step object:  gen_description,
+  a general description of what it is that should be extracted; fields, which is an array of the fields in each object that is 
+  extracted from the text, each with a name, a type and a description; multiple a boolean and that indicates whether exactly one object 
+  or an array with any number of objects should be extracted; and answer_field, the name of the variable should be written to in the
+  context (as an object if multiple is false and as an array if multiple is true).`;
+  }
+
+  static async execute(
+    { workflow_steps, workflow_name, when_trigger, trigger_table },
+    req
+  ) {
+    const steps = this.process_all_steps(workflow_steps);
+    let table_id;
+    if (trigger_table) {
+      const table = Table.findOne({ name: trigger_table });
+      if (!table) return { postExec: `Table not found: ${trigger_table}` };
+      table_id = table.id;
+    }
+    const trigger = await Trigger.create({
+      name: workflow_name,
+      when_trigger: when_trigger || "Never",
+      table_id,
+      action: "Workflow",
+      configuration: {},
+    });
+    for (const step of steps) {
+      step.trigger_id = trigger.id;
+      await WorkflowStep.create(step);
+    }
+    Trigger.emitEvent("AppChange", `Trigger ${trigger.name}`, req?.user, {
+      entity_type: "Trigger",
+      entity_name: trigger.name,
+    });
+    return {
+      postExec:
+        "Workflow created. " +
+        a(
+          { target: "_blank", href: `/actions/configure/${trigger.id}` },
+          "Configure workflow."
+        ),
+    };
+  }
+
+  static render_html({
+    workflow_steps,
+    workflow_name,
+    when_trigger,
+    trigger_table,
+  }) {
+    const steps = this.process_all_steps(workflow_steps);
+
+    if (WorkflowStep.generate_diagram) {
+      steps.forEach((step, ix) => {
+        step.id = ix + 1;
+      });
+      const mmdia = WorkflowStep.generate_diagram(
+        steps.map((s) => new WorkflowStep(s))
+      );
+      return (
+        div(
+          `${workflow_name}${when_trigger ? `: ${when_trigger}` : ""}${
+            trigger_table ? ` on ${trigger_table}` : ""
+          }`
+        ) +
+        pre({ class: "mermaid" }, mmdia) +
+        script(`mermaid.run({querySelector: 'pre.mermaid'});`)
+      );
+    }
+
+    return `A workflow! Step names: ${workflow_steps.map(
+      (s) => s.step_name
+    )}. Upgrade Saltcorn to see diagrams in copilot`;
+  }
+
+  //specific methods
+
+  static process_all_steps(steps) {
+    const scsteps = steps.map((s) => this.to_saltcorn_step(s));
+    if (scsteps.length) scsteps[0].initial_step = true;
+    return scsteps;
+  }
+
+  static to_saltcorn_step(llm_step) {
+    const { step_type, ...configuration } = llm_step.step_configuration;
+    return {
+      name: llm_step.step_name,
+      action_name: step_type,
+      next_step: llm_step.next_step,
+      only_if: llm_step.only_if,
+      configuration,
+    };
+  }
+}
+
+module.exports = GenerateWorkflow;

package/chat-copilot.js

@@ -0,0 +1,471 @@
+const Field = require("@saltcorn/data/models/field");
+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 { 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 } = 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 {
+  getCompletion,
+  getPromptFromTemplate,
+  incompleteCfgMsg,
+} = require("./common");
+
+const get_state_fields = () => [];
+
+const run = async (table_id, viewname, cfg, state, { res, req }) => {
+  const prevRuns = (
+    await WorkflowRun.find(
+      { trigger_id: null },
+      { orderBy: "started_at", orderDesc: true, limit: 30 }
+    )
+  ).filter((r) => r.context.interactions);
+  const cfgMsg = incompleteCfgMsg();
+  if (cfgMsg) return cfgMsg;
+  let runInteractions = "";
+  if (state.run_id) {
+    const run = prevRuns.find((r) => r.id == state.run_id);
+    const interactMarkups = [];
+    for (const interact of run.context.interactions) {
+      switch (interact.role) {
+        case "user":
+          interactMarkups.push(
+            div(
+              { class: "interaction-segment" },
+              span({ class: "badge bg-secondary" }, "You"),
+              p(interact.content)
+            )
+          );
+          break;
+        case "assistant":
+        case "system":
+          if (interact.tool_calls) {
+            for (const tool_call of interact.tool_calls) {
+              const markup = await renderToolcall(
+                tool_call,
+                viewname,
+                (run.context.implemented_fcall_ids || []).includes(
+                  tool_call.id
+                ),
+                run
+              );
+              interactMarkups.push(
+                div(
+                  { class: "interaction-segment" },
+                  span({ class: "badge bg-secondary" }, "Copilot"),
+                  markup
+                )
+              );
+            }
+          } else
+            interactMarkups.push(
+              div(
+                { class: "interaction-segment" },
+                span({ class: "badge bg-secondary" }, "Copilot"),
+                p(interact.content)
+              )
+            );
+          break;
+        case "tool":
+          //ignore
+          break;
+      }
+    }
+    runInteractions = interactMarkups.join("");
+  }
+  const input_form = form(
+    {
+      onsubmit:
+        "event.preventDefault();spin_send_button();view_post('Saltcorn Copilot', 'interact', $(this).serialize(), processCopilotResponse);return false;",
+      class: "form-namespace copilot mt-2",
+      method: "post",
+    },
+    input({
+      type: "hidden",
+      name: "_csrf",
+      value: req.csrfToken(),
+    }),
+    input({
+      type: "hidden",
+      class: "form-control  ",
+      name: "run_id",
+      value: state.run_id ? +state.run_id : undefined,
+    }),
+    div(
+      { class: "copilot-entry" },
+      textarea({
+        class: "form-control",
+        name: "userinput",
+        "data-fieldname": "userinput",
+        placeholder: "How can I help you?",
+        id: "inputuserinput",
+        rows: "3",
+        autofocus: true,
+      }),
+      span(
+        { class: "submit-button p-2", onclick: "$('form.copilot').submit()" },
+        i({ id: "sendbuttonicon", class: "far fa-paper-plane" })
+      )
+    ),
+
+    i(
+      small(
+        "Skills you can request: " +
+          actionClasses.map((ac) => ac.title).join(", ")
+      )
+    )
+  );
+  return {
+    widths: [3, 9],
+    gx: 3,
+    besides: [
+      {
+        type: "container",
+        contents: div(
+          div(
+            {
+              class: "d-flex justify-content-between align-middle mb-2",
+            },
+            h5("Sessions"),
+
+            button(
+              {
+                type: "button",
+                class: "btn btn-secondary btn-sm",
+                onclick: "unset_state_field('run_id')",
+                title: "New session",
+              },
+              i({ class: "fas fa-redo" })
+            )
+          ),
+          prevRuns.map((run) =>
+            div(
+              {
+                onclick: `set_state_field('run_id',${run.id})`,
+                class: "prevcopilotrun",
+              },
+              localeDateTime(run.started_at),
+
+              p(
+                { class: "prevrun_content" },
+                run.context.interactions[0]?.content
+              )
+            )
+          )
+        ),
+      },
+      {
+        type: "container",
+        contents: div(
+          { class: "card" },
+          div(
+            { class: "card-body" },
+            script({
+              src: `/static_assets/${db.connectObj.version_tag}/mermaid.min.js`,
+            }),
+            script(
+              { type: "module" },
+              `mermaid.initialize({securityLevel: 'loose'${
+                getState().getLightDarkMode(req.user) === "dark"
+                  ? ",theme: 'dark',"
+                  : ""
+              }});`
+            ),
+            div({ id: "copilotinteractions" }, runInteractions),
+            input_form,
+            style(
+              `div.interaction-segment:not(:first-child) {border-top: 1px solid #e7e7e7; }
+              div.interaction-segment {padding-top: 5px;padding-bottom: 5px;}
+              div.interaction-segment p {margin-bottom: 0px;}
+              div.interaction-segment div.card {margin-top: 0.5rem;}
+            div.prevcopilotrun {border-top: 1px solid #e7e7e7;border-right: 1px solid #e7e7e7;padding-top:3px; padding-bottom:3px; padding-right: 1rem;}
+            div.prevcopilotrun:hover {cursor: pointer}
+            .copilot-entry .submit-button:hover { cursor: pointer}
+
+            .copilot-entry .submit-button {
+              position: relative; 
+              top: -1.8rem;
+              left: 0.1rem;              
+            }
+            .copilot-entry {margin-bottom: -1.25rem; margin-top: 1rem;}
+            p.prevrun_content {
+               white-space: nowrap;
+    overflow: hidden;
+    margin-bottom: 0px;
+    display: block;
+    text-overflow: ellipsis;}`
+            ),
+            script(`function processCopilotResponse(res) {
+        $("#sendbuttonicon").attr("class","far fa-paper-plane");
+        const $runidin= $("input[name=run_id")
+        if(res.run_id && (!$runidin.val() || $runidin.val()=="undefined"))
+          $runidin.val(res.run_id);
+        const wrapSegment = (html, who) => '<div class="interaction-segment"><span class="badge bg-secondary">'+who+'</span>'+html+'</div>'
+        $("#copilotinteractions").append(wrapSegment('<p>'+$("textarea[name=userinput]").val()+'</p>', "You"))
+        $("textarea[name=userinput]").val("")
+
+        for(const action of res.actions||[]) {
+            $("#copilotinteractions").append(wrapSegment(action, "Copilot"))
+          
+        }
+
+        if(res.response)
+            $("#copilotinteractions").append(wrapSegment('<p>'+res.response+'</p>', "Copilot"))
+    }
+    function restore_old_button_elem(btn) {
+        const oldText = $(btn).data("old-text");
+        btn.html(oldText);
+        btn.css({ width: "" });
+        btn.removeData("old-text");
+    }
+    function processExecuteResponse(res) {
+        const btn = $("#exec-"+res.fcall_id)
+        restore_old_button_elem($("#exec-"+res.fcall_id))
+        btn.prop('disabled', true);
+        btn.html('<i class="fas fa-check me-1"></i>Applied')
+        btn.removeClass("btn-primary")
+        btn.addClass("btn-secondary")
+        if(res.postExec) {
+          $('#postexec-'+res.fcall_id).html(res.postExec)
+        }
+    }
+    function submitOnEnter(event) {
+        if (event.which === 13) {
+            if (!event.repeat) {
+                const newEvent = new Event("submit", {cancelable: true});
+                event.target.form.dispatchEvent(newEvent);
+            }
+
+            event.preventDefault(); // Prevents the addition of a new line in the text field
+        }        
+    }
+    document.getElementById("inputuserinput").addEventListener("keydown", submitOnEnter);
+    function spin_send_button() {
+      $("#sendbuttonicon").attr("class","fas fa-spinner fa-spin");
+    }
+`)
+          )
+        ),
+      },
+    ],
+  };
+};
+
+const ellipsize = (s, nchars) => {
+  if (!s || !s.length) return "";
+  if (s.length <= (nchars || 20)) return text_attr(s);
+  return text_attr(s.substr(0, (nchars || 20) - 3)) + "...";
+};
+
+const actionClasses = [
+  require("./actions/generate-workflow"),
+  require("./actions/generate-tables"),
+  require("./actions/generate-js-action"),
+];
+
+const getCompletionArguments = async () => {
+  const tools = [];
+  const sysPrompts = [];
+  for (const actionClass of actionClasses) {
+    tools.push({
+      type: "function",
+      function: {
+        name: actionClass.function_name,
+        description: actionClass.description,
+        parameters: await actionClass.json_schema(),
+      },
+    });
+    sysPrompts.push(await actionClass.system_prompt());
+  }
+  const systemPrompt =
+    "You are building application components in a database application builder called Saltcorn.\n\n" +
+    sysPrompts.join("\n\n");
+  return { tools, systemPrompt };
+};
+
+/*
+
+build a workflow that asks the user for their name and age
+
+*/
+
+const execute = async (table_id, viewname, config, body, { req }) => {
+  const { fcall_id, run_id } = body;
+
+  const run = await WorkflowRun.findOne({ id: +run_id });
+
+  const fcall = run.context.funcalls[fcall_id];
+  const actionClass = actionClasses.find(
+    (ac) => ac.function_name === fcall.name
+  );
+  const result = await actionClass.execute(JSON.parse(fcall.arguments), req);
+  await addToContext(run, { implemented_fcall_ids: [fcall_id] });
+  return { json: { success: "ok", fcall_id, ...(result || {}) } };
+};
+
+const interact = async (table_id, viewname, config, body, { req }) => {
+  const { userinput, run_id } = body;
+  let run;
+  if (!run_id || run_id === "undefined")
+    run = await WorkflowRun.create({
+      status: "Running",
+      context: {
+        implemented_fcall_ids: [],
+        interactions: [{ role: "user", content: userinput }],
+        funcalls: {},
+      },
+    });
+  else {
+    run = await WorkflowRun.findOne({ id: +run_id });
+    await addToContext(run, {
+      interactions: [{ role: "user", content: userinput }],
+    });
+  }
+  const complArgs = await getCompletionArguments();
+  complArgs.chat = run.context.interactions;
+  //console.log(complArgs);
+
+  //build a database for a bicycle rental company
+  //add a boolean field called "paid" to the payments table
+
+  const answer = await getState().functions.llm_generate.run(
+    userinput,
+    complArgs
+  );
+  await addToContext(run, {
+    interactions:
+      typeof answer === "object" && answer.tool_calls
+        ? [
+            { role: "assistant", tool_calls: answer.tool_calls },
+            ...answer.tool_calls.map((tc) => ({
+              role: "tool",
+              tool_call_id: tc.id,
+              name: tc.function.name,
+              content: "Action suggested to user.",
+            })),
+          ]
+        : [{ role: "assistant", content: answer }],
+  });
+  console.log("answer", answer);
+
+  if (typeof answer === "object" && answer.tool_calls) {
+    const actions = [];
+    for (const tool_call of answer.tool_calls) {
+      await addToContext(run, {
+        funcalls: { [tool_call.id]: tool_call.function },
+      });
+      const markup = await renderToolcall(tool_call, viewname, false, run);
+
+      actions.push(markup);
+    }
+    return { json: { success: "ok", actions, run_id: run.id } };
+  } else return { json: { success: "ok", response: answer, run_id: run.id } };
+};
+
+const renderToolcall = async (tool_call, viewname, implemented, run) => {
+  const fname = tool_call.function.name;
+  const actionClass = actionClasses.find((ac) => ac.function_name === fname);
+  const args = JSON.parse(tool_call.function.arguments);
+
+  const inner_markup = await actionClass.render_html(args);
+  return wrapAction(
+    inner_markup,
+    viewname,
+    tool_call,
+    actionClass,
+    implemented,
+    run
+  );
+};
+
+const wrapAction = (
+  inner_markup,
+  viewname,
+  tool_call,
+  actionClass,
+  implemented,
+  run
+) =>
+  div(
+    { class: "card mb-3" },
+    div({ class: "card-header" }, h5(actionClass.title)),
+    div(
+      { class: "card-body" },
+      inner_markup,
+      implemented
+        ? button(
+            {
+              type: "button",
+              class: "btn btn-secondary d-block mt-3 float-end",
+              disabled: true,
+            },
+            i({ class: "fas fa-check me-1" }),
+            "Applied"
+          )
+        : button(
+            {
+              type: "button",
+              id: "exec-" + tool_call.id,
+              class: "btn btn-primary d-block mt-3 float-end",
+              onclick: `press_store_button(this, true);view_post('${viewname}', 'execute', {fcall_id: '${tool_call.id}', run_id: ${run.id}}, processExecuteResponse)`,
+            },
+            "Apply"
+          ),
+      div({ id: "postexec-" + tool_call.id })
+    )
+  );
+
+const addToContext = async (run, newCtx) => {
+  if (run.addToContext) return await run.addToContext(newCtx);
+  let changed = true;
+  Object.keys(newCtx).forEach((k) => {
+    if (Array.isArray(run.context[k])) {
+      if (!Array.isArray(newCtx[k]))
+        throw new Error("Must be array to append to array");
+      run.context[k].push(...newCtx[k]);
+      changed = true;
+    } else if (typeof run.context[k] === "object") {
+      if (typeof newCtx[k] !== "object")
+        throw new Error("Must be object to append to object");
+      Object.assign(run.context[k], newCtx[k]);
+      changed = true;
+    } else {
+      run.context[k] = newCtx[k];
+      changed = true;
+    }
+  });
+  if (changed) await run.update({ context: run.context });
+};
+
+module.exports = {
+  name: "Saltcorn Copilot",
+  display_state_form: false,
+  get_state_fields,
+  tableless: true,
+  singleton: true,
+  run,
+  routes: { interact, execute },
+};

package/common.js

@@ -57,4 +57,50 @@ const incompleteCfgMsg = () => {
   }
 };
 
-module.exports = { getCompletion, getPromptFromTemplate, incompleteCfgMsg };
+const toArrayOfStrings = (opts) => {
+  if (typeof opts === "string") return opts.split(",").map((s) => s.trim());
+  if (Array.isArray(opts))
+    return opts.map((o) => (typeof o === "string" ? o : o.value || o.name));
+};
+
+const fieldProperties = (field) => {
+  const props = {};
+  const typeName = field.type?.name || field.type || field.input_type;
+  if (field.isRepeat) {
+    props.type = "array";
+    const properties = {};
+    field.fields.map((f) => {
+      properties[f.name] = {
+        description: f.sublabel || f.label,
+        ...fieldProperties(f),
+      };
+    });
+    props.items = {
+      type: "object",
+      properties,
+    };
+  }
+  switch (typeName) {
+    case "String":
+      props.type = "string";
+      if (field.attributes?.options)
+        props.enum = toArrayOfStrings(field.attributes.options);
+      break;
+    case "Bool":
+      props.type = "boolean";
+      break;
+    case "Integer":
+      props.type = "integer";
+      break;
+    case "Float":
+      props.type = "number";
+      break;
+    case "select":
+      props.type = "string";
+      if (field.options) props.enum = toArrayOfStrings(field.options);
+      break;
+  }
+  return props;
+};
+
+module.exports = { getCompletion, getPromptFromTemplate, incompleteCfgMsg, fieldProperties };

package/index.js

@@ -1,5 +1,6 @@
 const Workflow = require("@saltcorn/data/models/workflow");
 const Form = require("@saltcorn/data/models/form");
+const { features } = require("@saltcorn/data/db/state");
 
 const configuration_workflow = () =>
   new Workflow({
@@ -10,5 +11,10 @@ module.exports = {
   sc_plugin_api_version: 1,
   //configuration_workflow,
   dependencies: ["@saltcorn/large-language-model"],
-  viewtemplates: [require("./action-builder"), require("./database-designer")],
+  viewtemplates: features.workflows
+    ? [require("./chat-copilot")]
+    : [require("./action-builder"), require("./database-designer")],
+  functions: features.workflows
+    ? { copilot_generate_workflow: require("./workflow-gen") }
+    : {},
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saltcorn/copilot",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "AI assistant for building Saltcorn applications",
   "main": "index.js",
   "dependencies": {
@@ -15,7 +15,7 @@
   "eslintConfig": {
     "extends": "eslint:recommended",
     "parserOptions": {
-      "ecmaVersion": 2020
+      "ecmaVersion": 2022
     },
     "env": {
       "node": true,

package/prompts/action-builder.txt

@@ -300,8 +300,4 @@ value should be an object with keys that are field variable names. Example:
 return { set_fields: {
     zidentifier: `${name.toUpperCase()}-${id}`
   }
-}
-
-Write the JavaScript code to implement the following functionality:
-
-{{ userPrompt }}
+}

package/workflow-gen.js

@@ -0,0 +1,45 @@
+const { getState } = require("@saltcorn/data/db/state");
+const WorkflowStep = require("@saltcorn/data/models/workflow_step");
+const Trigger = require("@saltcorn/data/models/trigger");
+const { getActionConfigFields } = require("@saltcorn/data/plugin-helper");
+const GenerateWorkflow = require("./actions/generate-workflow");
+
+const workflow_function = async () => ({
+  type: "function",
+  function: {
+    name: "generate_workflow",
+    description: "Generate the steps in a workflow",
+    parameters: await GenerateWorkflow.json_schema(),
+  },
+});
+
+module.exports = {
+  run: async (description) => {
+    const rnd = Math.round(100 * Math.random());
+    const systemPrompt = await GenerateWorkflow.system_prompt();
+
+    const toolargs = {
+      tools: [await workflow_function()],
+      tool_choice: {
+        type: "function",
+        function: { name: "generate_workflow" },
+      },
+      systemPrompt,
+    };
+    const prompt = `Design a workflow to implement a workflow accorfing to the following specification: ${description}`;
+    console.log(prompt);
+    console.log(JSON.stringify(toolargs, null, 2));
+
+    const answer = await getState().functions.llm_generate.run(
+      prompt,
+      toolargs
+    );
+    const resp = JSON.parse(answer.tool_calls[0].function.arguments);
+    const scsteps = resp.workflow_steps.map(GenerateWorkflow.to_saltcorn_step);
+
+    return scsteps;
+  },
+  isAsync: true,
+  description: "Generate a workflow",
+  arguments: [{ name: "description", type: "String" }],
+};