@saltcorn/copilot 0.7.5 → 0.8.0

package/app-constructor/tasks.js

@@ -0,0 +1,401 @@
+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,
+  a,
+  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 { runTask, runNextTask } = require("./run_task");
+const { task_tool } = require("./tools");
+const { saltcorn_description, existing_tables_list } = require("./prompts");
+
+const makeTaskList = async (req) => {
+  const rs = await MetaData.find(
+    {
+      type: "CopilotConstructMgr",
+      name: "task",
+    },
+    { orderBy: "written_at" }
+  );
+  const settings = await MetaData.findOne({
+    type: "CopilotConstructMgr",
+    name: "settings",
+  });
+  const running = !!settings?.body?.running;
+  const status = div(
+    running ? "Currently running" : "Currently not running",
+    running
+      ? button(
+          {
+            class: "btn btn-danger ms-2",
+            onclick: `view_post("${viewname}", "stop", {})`,
+          },
+          i({ class: "fas fa-stop me-1" }),
+          "Stop running"
+        )
+      : button(
+          {
+            class: "btn btn-success ms-2",
+            onclick: `view_post("${viewname}", "start", {})`,
+          },
+          i({ class: "fas fa-play me-1" }),
+          "Start running now"
+        ),
+    button(
+      {
+        class: "btn btn-outline-success ms-2",
+        onclick: `press_store_button(this);view_post("${viewname}", "run_task", {})`,
+      },
+      i({ class: "fas fa-play me-1" }),
+      "Run next task"
+    )
+  );
+  if (rs.length) {
+    return div(
+      { class: "mt-2" },
+      status,
+      mkTable(
+        [
+          { label: "Name", key: (m) => m.body.name },
+          { label: "Description", key: (m) => m.body.description },
+          {
+            label: "Depends on",
+            key: (m) => (m.body.depends_on || []).join(", "),
+          },
+          { label: "Priority", key: (m) => m.body.priority },
+          { label: "Status", key: (m) => m.body.status || "To do" },
+          {
+            label: "Run",
+            key: (r) =>
+              r.body.status === "Running"
+                ? span(
+                    {
+                      class: "task-spinner",
+                      "data-task-id": r.id,
+                    },
+                    i({ class: "fas fa-spinner fa-spin text-warning" })
+                  )
+                : r.body.status === "Done"
+                ? r.body.run_id
+                  ? a(
+                      {
+                        target: "_blank",
+                        href: `/view/Saltcorn%20Agent%20copilot?run_id=${r.body.run_id}`,
+                      },
+                      i({ class: "fas fa-external-link-alt" })
+                    )
+                  : ""
+                : button(
+                    {
+                      class: "btn btn-outline-success btn-sm",
+                      onclick: `press_store_button(this);view_post("${viewname}", "run_task", {id:${r.id}})`,
+                    },
+                    i({ class: "fas fa-play" })
+                  ),
+          },
+          {
+            label: "",
+            key: (r) =>
+              r.body.status === "To do" || !r.body.status
+                ? button(
+                    {
+                      class: "btn btn-outline-secondary btn-sm",
+                      title: "Mark as done without running",
+                      onclick: `view_post("${viewname}", "mark_done_task", {id:${r.id}})`,
+                    },
+                    i({ class: "fas fa-check" })
+                  )
+                : "",
+          },
+          {
+            label: "Delete",
+            key: (r) =>
+              button(
+                {
+                  class: "btn btn-outline-danger btn-sm",
+                  onclick: `view_post("${viewname}", "del_task", {id:${r.id}})`,
+                },
+                i({ class: "fas fa-trash-alt" })
+              ),
+          },
+        ],
+        {
+          "To do": rs.filter(
+            (t) => !t.body.status || t.body.status === "To do"
+          ),
+          Running: rs.filter((t) => t.body.status === "Running"),
+          Done: rs.filter((t) => t.body.status === "Done"),
+        },
+        { grouped: true }
+      ),
+      rs.some((t) => t.body.status === "Running")
+        ? script(
+            domReady(`
+(function() {
+  function pollTasks() {
+    var spinners = document.querySelectorAll('.task-spinner[data-task-id]');
+    if (!spinners.length) return;
+    var ids = Array.from(spinners).map(function(el) { return el.getAttribute('data-task-id'); });
+    view_post(${JSON.stringify(
+      viewname
+    )}, 'task_status', { ids: ids }, function(resp) {
+      if (resp && resp.any_done) {
+        location.reload();
+      } else {
+        setTimeout(pollTasks, 3000);
+      }
+    });
+  }
+  setTimeout(pollTasks, 3000);
+})();
+`)
+          )
+        : "",
+      button(
+        {
+          class: "btn btn-outline-danger mb-4",
+          onclick: `view_post("${viewname}", "del_all_tasks")`,
+        },
+        "Delete all"
+      )
+    );
+  } else {
+    return div(
+      { class: "mt-2" },
+      p("No tasks found"),
+      button(
+        {
+          class: "btn btn-primary",
+          onclick: `press_store_button(this);view_post("${viewname}", "gen_tasks")`,
+        },
+        "Plan tasks"
+      )
+    );
+  }
+};
+
+const gen_tasks = 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 rs = await MetaData.find({
+    type: "CopilotConstructMgr",
+    name: "requirement",
+  });
+  if (!rs.length) throw new Error("No requirements found");
+  const schema = await MetaData.findOne({
+    type: "CopilotConstructMgr",
+    name: "schema",
+  });
+  if (!schema) throw new Error("No schema found");
+  if (!schema.body.implemented) throw new Error("Schema not implemented");
+  const tables = await Table.find({});
+
+  const answer = await getState().functions.llm_generate.run(
+    `Generate a plan for building 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}
+
+These are the requirements of the application: 
+
+${rs.map((r) => `* ${r.body.requirement}`).join("\n")}
+
+${saltcorn_description}
+
+The database has already been built. The following tables are now present in the database:
+
+${existing_tables_list(tables)}
+
+The plan should outline the continued development of the application on top of this database. 
+Your plan can add additional tables if needed or adjust the table fields, but normally the tables 
+should be designed optimally for this application. 
+
+The plan should focus on building views, triggers (including workflows) and pages.
+
+Important view planning rules:
+* Do NOT plan separate tasks for "create" and "edit" on the same table. In Saltcorn, a single Edit view handles both (no id = create, id present = edit). Plan one task covering both, and write task descriptions that say "create and edit" rather than treating them as two separate items.
+* When a table has foreign key fields referencing the users table, the task description must explicitly state for each one whether it is an ownership field (automatically set from the logged-in user, omit from the form) or a selector field (the user picks a value, include a selector in the form). Example: "user_id records the owner and is set automatically; shared_with_user_id must have a user selector."
+* For FK fields that represent a parent context (e.g. trip_id on packing_items), always include the field as a normal selector in the Edit view form. Do NOT say to omit it. Saltcorn automatically pre-fills the selector from the URL query parameter when the view is opened from a parent context, and the user can select it manually when the view is used standalone.
+* A List view that includes an edit link (viewlink column pointing to an Edit view) depends on that Edit view already existing. Always plan the Edit view task before the List view task, and set the List view task's depends_on to include the Edit view task name.
+* If a List view includes a viewlink to show record details (a Show view), the Show view must be created as a separate task before the List view task, and the List view task must depend on it. A Show view is a distinct viewtemplate — do NOT use an Edit view or a page as a substitute for it. The Show view and Edit view for the same table are independent — neither depends on the other; they can be planned in any order or in parallel.
+* In general, if a view embeds or links to another view, the linked view must be created first and listed as a dependency.
+
+* For every task that creates a view, include the exact view name in the task description. View names must be lowercase, snake_case, unique across all tasks in the plan (no two tasks may produce a view with the same name), and descriptive enough to identify the table and purpose — for example 'packing_items_edit' rather than just 'edit'.
+
+Important schema/table rules:
+* The database schema is already fully designed and implemented before task planning begins. ALL tables and fields needed by the application already exist. Do NOT plan any tasks that create tables, add fields, modify fields, or change the schema in any way. If you find yourself writing a task whose output is a table or a field, delete it — that work is already done.
+* Ownership behaviour (auto-setting a FK-to-users field from the logged-in user) is configured in the Edit view, not in the database. Do not create tasks for it at the schema level.
+* Do NOT plan tasks to add uniqueness constraints or validation to existing fields — those are already in the schema.
+
+Your plan 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.
+
+Do not include any steps that contain planning, design or review instructions. You are only writing a
+plan for the engineer building the application. Every step in the plan should have the construction or the modification
+of one or several application entity types. 
+
+Now use the plan_tasks tool to make a plan of tasks for building software application
+`,
+    {
+      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",
+    }
+  );
+
+  const tc = answer.getToolCalls()[0];
+
+  for (const task of tc.input.tasks)
+    await MetaData.create({
+      type: "CopilotConstructMgr",
+      name: "task",
+      body: task,
+      user_id: req.user?.id,
+    });
+  return { json: { reload_page: true } };
+};
+
+const del_task = async (table_id, viewname, config, body, { req, res }) => {
+  const r = await MetaData.findOne({
+    id: body.id,
+  });
+
+  if (!r) throw new Error("Task not found");
+  await r.delete();
+  return { json: { reload_page: true } };
+};
+const run_task = async (table_id, viewname, config, body, { req, res }) => {
+  const reqUser = req?.user;
+  setImmediate(async () => {
+    try {
+      if (body.id) await runTask(body.id, { user: reqUser, __: req.__ });
+      else await runNextTask(true);
+    } catch (e) {
+      console.error("run_task background error", e);
+    }
+  });
+  return { json: { reload_page: true } };
+};
+
+const task_status = async (table_id, viewname, config, body, { req, res }) => {
+  const ids = body.ids || [];
+  const tasks = await MetaData.find({
+    type: "CopilotConstructMgr",
+    name: "task",
+  });
+  const relevant = tasks.filter((t) => ids.includes(String(t.id)));
+  const any_done = relevant.some((t) => t.body.status !== "Running");
+  return { json: { any_done } };
+};
+
+const start = async (table_id, viewname, config, body, { req, res }) => {
+  const settings = await MetaData.findOne({
+    type: "CopilotConstructMgr",
+    name: "settings",
+  });
+  if (settings)
+    await settings.update({ body: { ...settings.body, running: true } });
+  else
+    await MetaData.create({
+      type: "CopilotConstructMgr",
+      name: "settings",
+      body: { running: true },
+    });
+  return { json: { reload_page: true } };
+};
+const stop = async (table_id, viewname, config, body, { req, res }) => {
+  const settings = await MetaData.findOne({
+    type: "CopilotConstructMgr",
+    name: "settings",
+  });
+  if (settings)
+    await settings.update({ body: { ...settings.body, running: false } });
+  else
+    await MetaData.create({
+      type: "CopilotConstructMgr",
+      name: "settings",
+      body: { running: false },
+    });
+  return { json: { reload_page: true } };
+};
+
+const mark_done_task = async (
+  table_id,
+  viewname,
+  config,
+  body,
+  { req, res }
+) => {
+  const r = await MetaData.findOne({ id: body.id });
+  if (!r) throw new Error("Task not found");
+  await r.update({ body: { ...r.body, status: "Done" } });
+  return { json: { reload_page: true } };
+};
+
+const del_all_tasks = async (
+  table_id,
+  viewname,
+  config,
+  body,
+  { req, res }
+) => {
+  const rs = await MetaData.find({
+    type: "CopilotConstructMgr",
+    name: "task",
+  });
+  for (const r of rs) await r.delete();
+  return { json: { reload_page: true } };
+};
+
+const task_routes = {
+  gen_tasks,
+  del_task,
+  del_all_tasks,
+  mark_done_task,
+  run_task,
+  task_status,
+  start,
+  stop,
+};
+
+module.exports = { makeTaskList, task_routes };

package/app-constructor/tools.js

@@ -0,0 +1,81 @@
+const requirements_tool = {
+  type: "function",
+  function: {
+    name: "make_requirements",
+    description: "Provide a list of requirements for the application",
+    parameters: {
+      type: "object",
+      required: ["requirements"],
+      additionalProperties: false,
+      properties: {
+        requirements: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["requirement", "priority"],
+            additionalProperties: false,
+            properties: {
+              requirement: {
+                type: "string",
+                description: "A statement of the requirement",
+              },
+              priority: {
+                type: "number",
+                description:
+                  "Priority 1-5. 5: Most important, 1: Least important",
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+};
+
+const task_tool = {
+  type: "function",
+  function: {
+    name: "plan_tasks",
+    description: "Provide a series of tasks for building the application",
+    parameters: {
+      type: "object",
+      required: ["tasks"],
+      additionalProperties: false,
+      properties: {
+        tasks: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["requirement", "priority"],
+            additionalProperties: false,
+            properties: {
+              name: {
+                type: "string",
+                description: "A short name for the task",
+              },
+              description: {
+                type: "string",
+                description: "A full description of the task",
+              },
+              priority: {
+                type: "number",
+                description:
+                  "Priority 1-5. 5: Most important, 1: Least important",
+              },
+              depends_on: {
+                type: "array",
+                description:
+                  "The names of the tasks that must be completed before this tasks can be started",
+                items: {
+                  type: "string",
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+};
+
+module.exports = { requirements_tool,task_tool };

package/app-constructor/view.js

@@ -0,0 +1,209 @@
+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 { requirementsList, req_routes } = require("./requirements");
+const { showSchema, schema_routes } = require("./schema");
+const { makeTaskList, task_routes } = require("./tasks");
+const { errorList, error_routes } = require("./errors");
+const { feedbackList, feedback_routes } = require("./feedback");
+const { progressList, progress_routes } = require("./progress");
+const { runNextTask } = require("./run_task");
+const { makeTaskChart } = require("./taskchart");
+
+const get_state_fields = () => [];
+
+const sys_prompt = ``;
+
+const makeSpecForm = async (req) => {
+  const spec = await MetaData.findOne({
+    type: "CopilotConstructMgr",
+    name: "spec",
+  });
+
+  return new Form({
+    blurb: "Provide a high-level description of the application",
+    fields: [
+      {
+        name: "description",
+        label: "Description",
+        type: "String",
+        fieldview: "textarea",
+      },
+      {
+        name: "audience",
+        label: "Audience",
+        type: "String",
+        fieldview: "textarea",
+      },
+      {
+        name: "core_features",
+        label: "Core features",
+        type: "String",
+        fieldview: "textarea",
+      },
+      {
+        name: "out_of_scope",
+        label: "Out of scope",
+        type: "String",
+        fieldview: "textarea",
+      },
+      {
+        name: "visual_style",
+        label: "Visual style",
+        type: "String",
+        fieldview: "textarea",
+      },
+    ],
+    xhrSubmit: true,
+    action: `/view/${encodeURIComponent(viewname)}/submit_specs`,
+    values: spec?.body || {},
+  });
+};
+
+const run = async (table_id, viewname, cfg, state, { req, res }) => {
+  const specForm = await makeSpecForm(req);
+  const reqList = await requirementsList(req);
+  const taskList = await makeTaskList(req);
+  const errList = await errorList(req);
+  const feedbacks = await feedbackList(req);
+  const progress = await progressList(req);
+  const taskChart = await makeTaskChart(req);
+  const schema = await showSchema(req);
+  const layout = {
+    type: "tabs",
+    ntabs: 5,
+    tabId: "",
+    lazyLoadViews: true,
+    titles: [
+      "Specification",
+      "Requirements",
+      "Schema",
+      "Tasks",
+      "Task chart",
+      "Progress",
+      "Feedback",
+      "Errors",
+    ],
+    contents: [
+      {
+        type: "blank",
+        contents: div({ class: "mt-2" }, renderForm(specForm, req.csrfToken())),
+      },
+      { type: "blank", contents: reqList },
+      { type: "blank", contents: schema },
+      { type: "blank", contents: taskList },
+      { type: "blank", contents: taskChart },
+      { type: "blank", contents: progress },
+      { type: "blank", contents: feedbacks },
+      { type: "blank", contents: errList },
+    ],
+    deeplink: true,
+    tabsStyle: "Tabs",
+  };
+  return renderLayout({
+    blockDispatch: {},
+    layout,
+    role: req.user?.role_id || 100,
+    req,
+    hints: getState().getLayout(req.user).hints || {},
+  });
+};
+
+const submit_specs = async (table_id, viewname, config, body, { req, res }) => {
+  const { _csrf, ...spec } = body;
+  const existing = await MetaData.findOne({
+    type: "CopilotConstructMgr",
+    name: "spec",
+  });
+
+  if (existing) await db.update("_sc_metadata", { body: spec }, existing.id);
+  else
+    await MetaData.create({
+      type: "CopilotConstructMgr",
+      name: "spec",
+      user_id: req.user?.id || undefined,
+      body: spec,
+    });
+};
+
+const virtual_triggers = () => {
+  return [
+    {
+      when_trigger: "Error",
+      run: async (row) => {
+        const existing = await MetaData.find({
+          type: "CopilotConstructMgr",
+          name: "error",
+        });
+        const messages = new Set(existing.map((m) => m.body?.error?.stack));
+        if (!messages.has(row.stack))
+          await MetaData.create({
+            type: "CopilotConstructMgr",
+            name: "error",
+            body: { status: "New", error: row },
+            user_id: null,
+          });
+      },
+    },
+    {
+      when_trigger: "Often",
+      run: async () => {
+        await runNextTask();
+      },
+    },
+  ];
+};
+
+module.exports = {
+  name: viewname,
+  display_state_form: false,
+  get_state_fields,
+  tableless: true,
+  singleton: true,
+  run,
+  routes: {
+    submit_specs,
+    ...req_routes,
+    ...task_routes,
+    ...error_routes,
+    ...feedback_routes,
+    ...progress_routes,
+    ...schema_routes,
+  },
+  virtual_triggers,
+};