@saltcorn/copilot 0.7.4 → 0.8.0

package/app-constructor/feedback-action.js

@@ -0,0 +1,175 @@
+const { eval_expression } = require("@saltcorn/data/models/expression");
+const MetaData = require("@saltcorn/data/models/metadata");
+const { interpolate } = require("@saltcorn/data/utils");
+const { getState } = require("@saltcorn/data/db/state");
+const { requirements_tool, task_tool } = require("./tools");
+const { tool_choice } = require("./common");
+
+module.exports = {
+  description: "Provide user feedback to the AppConstructor",
+  configFields: ({ table, mode }) => {
+    if (mode === "workflow") {
+      return [
+        {
+          name: "title",
+          label: "Title",
+          sublabel:
+            "Feedback title. Use interpolations {{ }} to access variables in the context",
+          type: "String",
+        },
+        {
+          name: "description",
+          label: "Description",
+          sublabel:
+            "Feedback description. Use interpolations {{ }} to access variables in the context",
+          type: "String",
+        },
+        {
+          name: "url",
+          label: "URL",
+          sublabel:
+            "Feedback URL. Use interpolations {{ }} to access variables in the context",
+          type: "String",
+        },
+      ];
+    } else if (table) {
+      const textFields = table.fields
+        .filter((f) => f.type?.sql_name === "text")
+        .map((f) => f.name);
+      return [
+        {
+          name: "title_field",
+          label: "Title field",
+          type: "String",
+          attributes: { options: textFields },
+        },
+        {
+          name: "description_field",
+          label: "Description field",
+          type: "String",
+          attributes: { options: textFields },
+        },
+        {
+          name: "url_field",
+          label: "URL field",
+          type: "String",
+          attributes: { options: textFields },
+        },
+      ];
+    }
+  },
+  run: async ({
+    row,
+    table,
+    user,
+    mode,
+    req,
+    configuration: {
+      title,
+      description,
+      url,
+      title_field,
+      description_field,
+      url_field,
+    },
+  }) => {
+    const use_title =
+      mode === "workflow" ? interpolate(title, row, user) : row[title_field];
+    const use_description =
+      mode === "workflow"
+        ? interpolate(description, row, user)
+        : row[description_field];
+    const use_url =
+      mode === "workflow" ? interpolate(url, row, user) : row[url_field];
+    await MetaData.create({
+      type: "CopilotConstructMgr",
+      name: "feedback",
+      body: { title: use_title, description: use_description, url: use_url },
+      user_id: user?.id,
+    });
+    const spec = await MetaData.findOne({
+      type: "CopilotConstructMgr",
+      name: "spec",
+    });
+    if (!spec) return;
+    const reqAnswer = await getState().functions.llm_generate.run(
+      `The following application is being built:
+
+Description: ${spec.body.description}
+Audience: ${spec.body.audience}
+Core features: ${spec.body.core_features}
+Out of scope: ${spec.body.out_of_scope}
+Visual style: ${spec.body.visual_style}
+
+A new piece of feedback has come in from a user:
+
+Title: ${use_title}
+Description: ${use_description}
+
+Now use the make_requirements tool to create a single or several (a single is prefered) new requirements that captures this new piece of feedback.
+`,
+      {
+        tools: [requirements_tool],
+        ...tool_choice("make_requirements"),
+        systemPrompt:
+          "You are a project manager. The user wants to build an application, and you must analyse their application description and any feedback available",
+      },
+    );
+    const tc = reqAnswer.getToolCalls()[0];
+    console.log("gotr new requiremenrts", tc.input.requirements);
+
+    for (const reqm of tc.input.requirements)
+      await MetaData.create({
+        type: "CopilotConstructMgr",
+        name: "requirement",
+        body: reqm,
+        user_id: req.user?.id,
+      });
+
+    const taskAnswer = await getState().functions.llm_generate.run(
+      `The following application is being built:
+
+Description: ${spec.body.description}
+Audience: ${spec.body.audience}
+Core features: ${spec.body.core_features}
+Out of scope: ${spec.body.out_of_scope}
+Visual style: ${spec.body.visual_style}
+
+This application will be implemented in Saltcorn, a database application development
+environment. 
+
+A new piece of feedback has come in from a user:
+
+Title: ${use_title}
+Description: ${use_description}
+
+A product manager has determined that the following requirements should be added to the list of application requirements:
+
+${tc.input.requirements.map((r) => "  * " + r.requirement).join("\n")}
+
+Your plan for implementing this new fedback and requirements should not include any clarification or questions to the product owner. The 
+information you have been given so far is all that is available. Every step in the plan 
+should be immediately implementable in Saltcorn. You are writing the steps in the plan
+for a person who is competent in using saltcorn but has no other business knowledge.
+
+Now use the plan_tasks tool to create the tasks to implement this new feedback
+`,
+      {
+        tools: [task_tool],
+        ...tool_choice("plan_tasks"),
+        systemPrompt:
+          "You are a project manager. The user wants to build an application, and you must analyse their application description and any feedback available",
+      },
+    );
+    const tcTasks = taskAnswer.getToolCalls()[0];
+    console.log("got new tasks", tcTasks.input.tasks);
+
+    for (const task of tcTasks.input.tasks)
+      await MetaData.create({
+        type: "CopilotConstructMgr",
+        name: "task",
+        body: task,
+        user_id: req.user?.id,
+      });
+  },
+};

package/app-constructor/feedback.js

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

package/app-constructor/progress.js

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

package/app-constructor/prompts.js

@@ -0,0 +1,58 @@
+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")}`;
+};
+
+module.exports = { saltcorn_description, existing_tables_list };

package/app-constructor/requirements.js

@@ -0,0 +1,156 @@
+const Field = require("@saltcorn/data/models/field");
+const Table = require("@saltcorn/data/models/table");
+const Form = require("@saltcorn/data/models/form");
+const MetaData = require("@saltcorn/data/models/metadata");
+const View = require("@saltcorn/data/models/view");
+const Trigger = require("@saltcorn/data/models/trigger");
+const { findType } = require("@saltcorn/data/models/discovery");
+const { save_menu_items } = require("@saltcorn/data/models/config");
+const db = require("@saltcorn/data/db");
+const WorkflowRun = require("@saltcorn/data/models/workflow_run");
+const {
+  localeDateTime,
+  renderForm,
+  mkTable,
+  post_delete_btn,
+} = require("@saltcorn/markup");
+const {
+  div,
+  script,
+  domReady,
+  pre,
+  code,
+  input,
+  h4,
+  style,
+  h5,
+  button,
+  text_attr,
+  i,
+  p,
+  span,
+  small,
+  form,
+  textarea,
+} = require("@saltcorn/markup/tags");
+const { getState } = require("@saltcorn/data/db/state");
+const renderLayout = require("@saltcorn/markup/layout");
+const { viewname, tool_choice } = require("./common");
+const { requirements_tool } = require("./tools");
+
+const requirementsList = async (req) => {
+  const rs = await MetaData.find(
+    {
+      type: "CopilotConstructMgr",
+      name: "requirement",
+    },
+    { orderBy: "written_at" },
+  );
+  const starFieldview = getState().types.Integer.fieldviews.show_star_rating;
+
+  if (rs.length) {
+    return div(
+      { class: "mt-2" },
+      mkTable(
+        [
+          { label: "Requirement", key: (m) => m.body.requirement },
+          {
+            label: "Priority",
+            key: (m) =>
+              starFieldview.run(m.body.priority, req, { min: 1, max: 5 }),
+          },
+          {
+            label: "Delete",
+            key: (r) =>
+              button(
+                {
+                  class: "btn btn-outline-danger btn-sm",
+                  onclick: `view_post("${viewname}", "del_req", {id:${r.id}})`,
+                },
+                i({ class: "fas fa-trash-alt" }),
+              ),
+          },
+        ],
+        rs,
+      ),
+      button(
+        {
+          class: "btn btn-outline-danger mb-4",
+          onclick: `view_post("${viewname}", "del_all_reqs")`,
+        },
+        "Delete all",
+      ),
+    );
+  } else {
+    return div(
+      { class: "mt-2" },
+      p("No requirements found"),
+      button(
+        {
+          class: "btn btn-primary",
+          onclick: `press_store_button(this);view_post("${viewname}", "gen_reqs")`,
+        },
+        "Generate requirements",
+      ),
+    );
+  }
+};
+
+const gen_reqs = async (table_id, viewname, config, body, { req, res }) => {
+  const spec = await MetaData.findOne({
+    type: "CopilotConstructMgr",
+    name: "spec",
+  });
+  if (!spec) throw new Error("Specification not found");
+  const answer = await getState().functions.llm_generate.run(
+    `Generate the requirements for this application:
+
+Description: ${spec.body.description}
+Audience: ${spec.body.audience}
+Core features: ${spec.body.core_features}
+Out of scope: ${spec.body.out_of_scope}
+Visual style: ${spec.body.visual_style}
+
+Now use the make_requirements tool to list the requirements for this software application
+`,
+    {
+      tools: [requirements_tool],
+      ...tool_choice("make_requirements"),
+      systemPrompt:
+        "You are a project manager. The user wants to build an application, and you must analyse their application description",
+    },
+  );
+
+  const tc = answer.getToolCalls()[0];
+
+  for (const reqm of tc.input.requirements)
+    await MetaData.create({
+      type: "CopilotConstructMgr",
+      name: "requirement",
+      body: reqm,
+      user_id: req.user?.id,
+    });
+  return { json: { reload_page: true } };
+};
+
+const del_req = async (table_id, viewname, config, body, { req, res }) => {
+  const r = await MetaData.findOne({
+    id: body.id,
+  });
+
+  if (!r) throw new Error("Requirement not found");
+  await r.delete();
+  return { json: { reload_page: true } };
+};
+const del_all_reqs = async (table_id, viewname, config, body, { req, res }) => {
+  const rs = await MetaData.find({
+    type: "CopilotConstructMgr",
+    name: "requirement",
+  });
+  for (const r of rs) await r.delete();
+  return { json: { reload_page: true } };
+};
+
+const req_routes = { gen_reqs, del_req, del_all_reqs };
+
+module.exports = { requirementsList, req_routes };