@celsoft/coordinator 0.0.0 → 0.1.0

package/build/chunk-HGYE3UTU.js

@@ -0,0 +1,416 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  external_exports,
+  isRepo,
+  splitAt
+} from "./chunk-NCZ77J5E.js";
+
+// build/server/chunks/track.js
+var AnchoredPath = external_exports.string().regex(/^(\$COORDINATOR_ROOT|\$DEVELOPMENT|~)(\/.*)?$/, `A path under $COORDINATOR_ROOT, $DEVELOPMENT, or ~, never an absolute one.`);
+var ChecklistSelection = external_exports.union([
+  external_exports.literal("all"),
+  external_exports.literal("none"),
+  external_exports.array(external_exports.string())
+]);
+function isSelected(selection, item) {
+  if (selection === "all") return !item.disabled;
+  if (selection === "none") return false;
+  return selection.includes(item.id);
+}
+var PartName = external_exports.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "Name it in lowercase words joined by hyphens.").max(40, "Keep it to 40 characters.");
+var ProfileName = PartName;
+var EVENTS = {
+  agent_started: {
+    label: "Agent started",
+    when: "An agent starts or resumes in the repo.",
+    how: "Its handlers are added to the agent's start prompt, after who and where it is.",
+    source: "The launch, building the start prompt."
+  },
+  plan_approved: {
+    label: "Plan approved",
+    when: "The agent records that the user approved its plan, before it builds.",
+    how: "Its handlers reach the agent in a bus Message, which wakes it.",
+    source: "issue_plan with approved: true, from the issue's holder."
+  },
+  land_refused: {
+    label: "Land refused",
+    when: "The bus refuses the agent's land, or the landing fails.",
+    how: "Its handlers reach the agent in a bus Message, which wakes it.",
+    source: "A Landing ending refused or failed."
+  },
+  pr_feedback: {
+    label: "PR feedback",
+    when: "The agent's PR gets a review, a comment, a failed check, or a conflict.",
+    how: "Its handlers reach the agent in a bus Message, which wakes it.",
+    source: "The PR watcher, telling the slot what changed."
+  },
+  lead_given: {
+    label: "Lead given",
+    when: "The user gives the agent's slot a lead.",
+    how: "Its handlers follow the handover, in a bus Message to the agent.",
+    source: "The lead Message Type, or a follower brought up under a lead."
+  },
+  lead_cleared: {
+    label: "Lead cleared",
+    when: "The user clears the agent's lead.",
+    how: "Its handlers follow the release, in a bus Message to the agent.",
+    source: "The lead Message Type with no lead."
+  },
+  follower_added: {
+    label: "Follower added",
+    when: "The agent's slot becomes the lead of another.",
+    how: "Its handlers follow the briefing, in a bus Message to the agent.",
+    source: "The lead Message Type, or a follower brought up under it."
+  },
+  follower_removed: {
+    label: "Follower removed",
+    when: "The user clears the lead of one of the agent's followers.",
+    how: "Its handlers follow the notice, in a bus Message to the agent.",
+    source: "The lead Message Type with no lead."
+  },
+  turn_ended: {
+    label: "Turn ended",
+    when: "The agent finishes a turn and comes to rest; each handler of it, a Reminder, is given every so many turns, as it says.",
+    how: "Its handlers come in a quiet bus Message that never wakes the agent; it hears of it on its next turn, and no other is given while one waits.",
+    source: "The tracker, seeing the agent come to rest in Herdr."
+  },
+  landed: {
+    label: "Landed",
+    when: "The agent's work reaches the default branch, before the agent ends.",
+    how: "Its handlers reach the agent in a bus Message, which wakes it.",
+    source: "The bus recording the landing, from land or landed."
+  }
+};
+var Event = external_exports.enum(Object.keys(EVENTS));
+var COMMON_VARIABLES = {
+  repo: "The agent's repo, as org/repo.",
+  track: "The agent's track.",
+  slot: "The agent's slot, as org/repo@track.",
+  worktree: "The folder the agent works in.",
+  user: "Your name."
+};
+var EVENT_VARIABLES = {
+  plan_approved: { issue: "The issue whose plan was approved." },
+  land_refused: { issue: "The issue the landing was for." },
+  pr_feedback: { issue: "The issue the PR is for." },
+  landed: { issue: "The issue the work landed for." },
+  lead_given: { lead: "The agent's new lead, a slot." },
+  lead_cleared: { lead: "The slot that led the agent." },
+  follower_added: { follower: "The agent's new follower, a slot." },
+  follower_removed: { follower: "The slot that followed the agent." },
+  turn_ended: { turns: "How many turns the agent has finished." }
+};
+var variablesOf = (event) => ({
+  ...COMMON_VARIABLES,
+  ...EVENT_VARIABLES[event]
+});
+var PART_KINDS = {
+  profile: {
+    label: "Profile",
+    plural: "Profiles"
+  },
+  skill_group: {
+    label: "Skills",
+    plural: "Skills"
+  },
+  handler: {
+    label: "Event handler",
+    plural: "Event handlers"
+  },
+  event: {
+    label: "Event",
+    plural: "Events"
+  },
+  skill: {
+    label: "Skill",
+    plural: "Skills"
+  },
+  action: {
+    label: "Action",
+    plural: "Actions"
+  },
+  attachment: {
+    label: "Attached folder",
+    plural: "Attached folders"
+  }
+};
+var EditableKind = external_exports.enum(["profile", "attachment"]);
+var Description = external_exports.string().max(300, "Keep it to 300 characters.");
+var GROUP_FIELDS = {
+  description: Description,
+  skills: external_exports.array(external_exports.string())
+};
+var Every = external_exports.number({ error: "Say how many turns." }).int("Say a whole number of turns.").min(1, "At least every turn.").max(100, "At most every 100 turns.");
+var everyText = (event, every) => event !== "turn_ended" ? null : (every ?? 10) === 1 ? "Every turn" : `Every ${every ?? 10} turns`;
+var Selection = ChecklistSelection;
+var OnFor = external_exports.string().regex(/^(\*|[A-Za-z0-9_.-]+\/(\*|[A-Za-z0-9_.-]+))$/, "Name a Repo as org/repo, an org as org/*, or every Repo as *.");
+var onFor = (on, repo) => on.some((r) => r === "*" || r === repo || r === repo.split("/")[0] + "/*");
+var ACTION_VIEWS = {
+  repo: {
+    label: "The repo view",
+    variables: ["repo", "user"]
+  },
+  slot: {
+    label: "The slot view",
+    variables: [
+      "repo",
+      "slot",
+      "track",
+      "user"
+    ]
+  },
+  issue: {
+    label: "The issue view",
+    variables: [
+      "repo",
+      "issue",
+      "user"
+    ]
+  }
+};
+external_exports.object({
+  name: PartName,
+  description: Description.default(""),
+  skills: GROUP_FIELDS.skills.default([])
+});
+external_exports.enum([
+  "default",
+  "extra",
+  "attached",
+  "npx",
+  "plugin"
+]);
+external_exports.object({ attachments: external_exports.record(external_exports.string(), external_exports.lazy(() => AttachmentSchema)).default({}) });
+var WRITING_RULE = "A task is the agent's first prompt, read beside its brief: the goal, numbered steps with the commands that matter, then what done looks like; a page at most, with know-how used again in a skill the profile chooses. A handler is said at every firing of its event, and a reminder every few turns, so keep each to a few lines. No length is enforced; long text dilutes what matters.";
+var ProfileHandlerSchema = external_exports.object({
+  name: PartName,
+  event: Event,
+  text: external_exports.string(),
+  every: Every.optional()
+});
+var ProfileActionSchema = external_exports.object({
+  name: PartName,
+  description: Description.default(""),
+  label: external_exports.string().trim().min(1, "Name the button.").max(24, "Keep it to 24 characters."),
+  view: external_exports.enum([
+    "repo",
+    "slot",
+    "issue"
+  ]),
+  task: external_exports.string().trim().min(1, "Say what the agent is to do.")
+});
+external_exports.object({
+  name: PartName,
+  description: Description.default(""),
+  skills: external_exports.record(PartName, Selection).default({}),
+  on_for: external_exports.array(OnFor).default([]),
+  handlers: external_exports.array(ProfileHandlerSchema).default([]),
+  actions: external_exports.array(ProfileActionSchema).default([])
+});
+var ATTACHMENT_FIELDS = {
+  description: Description,
+  path: external_exports.string().trim().min(1, "Name the folder.")
+};
+var AttachmentSchema = external_exports.object({
+  name: PartName,
+  description: Description.default(""),
+  path: AnchoredPath
+});
+external_exports.strictObject({
+  description: Description,
+  skills: external_exports.record(PartName, Selection),
+  on_for: external_exports.array(OnFor),
+  handlers: external_exports.array(ProfileHandlerSchema),
+  actions: external_exports.array(ProfileActionSchema)
+}).partial(), external_exports.strictObject(ATTACHMENT_FIELDS).partial();
+function actionsFor(profiles, repo, view) {
+  return profiles.filter((p) => !p.base && (p.defaults ? !p.off_for?.includes(repo) : onFor(p.on_for, repo))).flatMap((p) => p.actions.filter((a) => !view || a.view === view).map((a) => ({
+    ...a,
+    profile: p.name
+  })));
+}
+function profilesFor(profiles, repo, settings) {
+  const rank = (p) => settings.order.includes(p.name) ? settings.order.indexOf(p.name) : settings.order.length;
+  const on = profiles.filter((p) => !p.base && !p.defaults && onFor(p.on_for, repo)).sort((a, b) => rank(a) - rank(b) || a.name.localeCompare(b.name));
+  return [
+    ...profiles.filter((p) => p.base),
+    ...settings.defaults === "off" ? [] : profiles.filter((p) => p.defaults),
+    ...on
+  ];
+}
+var profileHash = (name) => "#pf=" + encodeURIComponent(name);
+var tabOf = (kind) => kind === "handler" ? "event" : kind === "attachment" ? "skill_group" : kind;
+var partHash = (kind, name) => `#sk=${kind}:${encodeURIComponent(name)}`;
+var LandingMethod = external_exports.enum(["push", "pr"]);
+var LandScript = external_exports.string().trim().max(300).transform((v) => v || null).nullable().refine((v) => v === null || /^[\w.@+-]+(\/[\w.@+-]+)*\.mjs$/.test(v) && !v.split("/").includes(".."), "Name a .mjs file in the repo, by its path from the repo's root, such as scripts/before-landing.mjs.");
+var DURING_EVERY = {
+  "1": "Every minute",
+  "2": "Every 2 minutes",
+  "5": "Every 5 minutes",
+  "15": "Every 15 minutes"
+};
+var REPO_CATEGORIES = {
+  work: {
+    title: "Work",
+    description: "How its agents' work reaches the default branch through the bus. Each change is saved on the repo and applies at once.",
+    icon: "box"
+  },
+  commands: {
+    title: "Landing scripts",
+    description: "Scripts in this repo, each a .mjs file, the server runs with its own Node around each landing. Each is read from the repo's checkout, so only landed code runs. Each change is saved on the repo and applies to the next land.",
+    icon: "terminal"
+  },
+  agents: {
+    title: "Agents",
+    description: "How its Agents run: the Profiles they get after base, naming the skills they load and the Event Handlers they are told. Each change applies from the next Agent's start.",
+    icon: "users"
+  }
+};
+var REPO_SETTINGS = {
+  order: {
+    label: "Profile order",
+    description: "The order its agents get the Profiles on for it, after base: the skills of each are added, and their Event Handlers told in turn. A Profile on for it but not named here comes last.",
+    category: "agents",
+    default: [],
+    schema: external_exports.array(ProfileName)
+  },
+  defaults: {
+    label: "defaults",
+    description: "Whether its agents get the built-in defaults Profile, the Default Skills. On unless you turn it off.",
+    category: "agents",
+    options: {
+      on: "On",
+      off: "Off"
+    },
+    default: "on",
+    schema: external_exports.enum(["on", "off"])
+  },
+  landing: {
+    label: "Landing Method",
+    description: "Push: agents' work moves the default branch and is pushed. Pull request: it is pushed as the slot's branch and opened as a PR. Until one is chosen, land is refused.",
+    category: "work",
+    options: {
+      push: "Push to the default branch",
+      pr: "Pull request"
+    },
+    default: null,
+    schema: LandingMethod.nullable()
+  },
+  pre_land: {
+    label: "Before landing",
+    description: "Runs on the slot's worktree once land's checks pass, before anything is pushed, as the default branch has the script, never the slot's branch. If it fails, nothing lands and the agent is told why, with the end of its output.",
+    category: "commands",
+    default: null,
+    placeholder: "scripts/before-landing.mjs",
+    schema: LandScript
+  },
+  during_land: {
+    label: "During landing",
+    description: "Runs in the repo's checkout while a landing's PR is open, on the schedule below, until it merges or closes. The bus expects nothing of it: it never waits on it or reads its result.",
+    category: "commands",
+    default: null,
+    placeholder: "scripts/during-landing.mjs",
+    schema: LandScript
+  },
+  during_every: {
+    label: "During landing runs",
+    description: "How often During landing runs. A run never starts while the last one is still going.",
+    category: "commands",
+    options: DURING_EVERY,
+    default: "2",
+    schema: external_exports.enum(Object.keys(DURING_EVERY))
+  },
+  post_land: {
+    label: "After landing",
+    description: "Runs in the repo's checkout once the work is on the default branch: after the push, or when its PR merges. If it fails, the work stays landed and you and the agent are told why.",
+    category: "commands",
+    default: null,
+    placeholder: "scripts/after-landing.mjs",
+    schema: LandScript
+  }
+};
+var RepoSettingsSchema = external_exports.object(Object.fromEntries(Object.entries(REPO_SETTINGS).map(([name, f]) => [name, f.schema.default(f.default)])));
+var RepoSettingsChange = external_exports.strictObject(Object.fromEntries(Object.entries(REPO_SETTINGS).map(([name, f]) => [name, f.schema.describe(f.description).optional()]))).refine((c) => Object.keys(c).length > 0, "Name at least one setting.");
+var NONE_LABEL = "Not chosen";
+var repoSettingsSchema = (listed = {}) => external_exports.object(Object.fromEntries(Object.entries(REPO_CATEGORIES).map(([id, c]) => [id, external_exports.object(Object.fromEntries(Object.entries(REPO_SETTINGS).filter(([, f]) => f.category === id).map(([name, f]) => {
+  if (Array.isArray(f.default)) return [name, external_exports.array(external_exports.string()).default(f.default).meta({
+    title: f.label,
+    description: f.description
+  })];
+  if (!f.options) return [name, external_exports.string().default(f.default ?? "").meta({
+    title: f.label,
+    description: f.description,
+    mono: true,
+    placeholder: f.placeholder
+  })];
+  const options = {
+    ...f.options,
+    ...listed[name]
+  };
+  const values = [...f.default === null ? [""] : [], ...Object.keys(options)];
+  return [name, external_exports.enum(values).default(f.default ?? "").meta({
+    title: f.label,
+    description: f.description,
+    labels: {
+      [""]: NONE_LABEL,
+      ...options
+    }
+  })];
+}))).meta(c)])));
+function shownSettings(settings) {
+  const out = {};
+  for (const [name, f] of Object.entries(REPO_SETTINGS)) (out[f.category] ??= {})[name] = settings[name] ?? "";
+  return out;
+}
+var storedValue = (v) => v === "" ? null : v;
+function settingLabel(name, value) {
+  return value == null ? NONE_LABEL : REPO_SETTINGS[name].options?.[String(value)] ?? String(value);
+}
+var TRACK_RULE = `A track is a git branch name of at most 100 characters, such as fix-login or web/login: no spaces or ~^:?*[\\, no .. or //, and no part starting with a dot or ending in .lock.`;
+var BRANCH_RULE = "Not a git branch name.";
+var BAD = /[\x00-\x20\x7f~^:?*[\\]|\.\.|\/\/|@\{|^[-/]|\/$|\.$|(^|\/)\.|\.lock(\/|$)/;
+function isBranch(value) {
+  return !!value && value !== "@" && value !== "HEAD" && !BAD.test(value);
+}
+var Branch = external_exports.string().refine(isBranch, BRANCH_RULE);
+var Track = external_exports.string().max(100, TRACK_RULE).refine(isBranch, TRACK_RULE);
+function isSlot(value) {
+  const [repo, track] = splitAt(value, "@");
+  return isRepo(repo) && Track.safeParse(track).success;
+}
+var Slot = external_exports.string().refine(isSlot, { error: (i) => `'${String(i.input)}' is not a slot, org/repo@track` });
+function caseClash(track, known) {
+  const lower = track.toLowerCase();
+  for (const k of known) if (k !== track && k.toLowerCase() === lower) return k;
+  return null;
+}
+
+export {
+  isSelected,
+  PartName,
+  EVENTS,
+  variablesOf,
+  PART_KINDS,
+  EditableKind,
+  everyText,
+  onFor,
+  ACTION_VIEWS,
+  WRITING_RULE,
+  actionsFor,
+  profilesFor,
+  profileHash,
+  tabOf,
+  partHash,
+  LandingMethod,
+  RepoSettingsSchema,
+  RepoSettingsChange,
+  repoSettingsSchema,
+  shownSettings,
+  storedValue,
+  settingLabel,
+  Branch,
+  Track,
+  isSlot,
+  Slot,
+  caseClash
+};