clavarium-binder 0.1.3 → 0.1.5-next.1

package/bin/binder.mjs

@@ -20,7 +20,7 @@ export const HELP = `binder: the lists you were given, and their records.
          [--cover PICTURE|none]          the picture the card is shown by: one attached (its ref), or a photo field
   binder move ID STATE                 past a gate, only what a person approved
   binder note ID "text"                a short note: a decision, a fact, a result
-  binder attach ID KIND REF ["title"]  KIND: message, file, asset, branch, link, record
+  binder attach ID KIND REF ["title"]  KIND: message, file, asset, branch, commit, link, record
   binder detach ID WHAT
   binder archive ID | binder restore ID
   binder new TEMPLATE ["title"]        a list of your own, when none you were given fits
@@ -36,7 +36,7 @@ You never approve: a person ticks what may go on. Talking with them stays in the
 The folder used is --dir FOLDER, else $BINDER_DIR, else the nearest ${FOLDER} folder from here up.
 binder ${VERSION}`;
 
-const VERBS = ['lists', 'show', 'get', 'search', 'add', 'edit', 'move', 'note', 'attach', 'detach', 'archive', 'restore', 'new', 'archive-list', 'restore-list'];
+const VERBS = ['lists', 'show', 'get', 'search', 'add', 'edit', 'move', 'note', 'attach', 'detach', 'archive', 'restore', 'new', 'archive-list', 'restore-list', 'columns'];
 
 /* A command line, read: [op, args] or a refusal. */
 export function read(argv) {
@@ -68,7 +68,13 @@ export function read(argv) {
         case 'detach': return rest.length === 2 ? ['detach', { id: rest[0], what: rest[1] }] : { refused: 'binder detach ID WHAT' };
         case 'new': return rest[0] ? ['create-list', { template: rest[0], title: rest.slice(1).join(' ') || undefined }] : { refused: 'binder new TEMPLATE ["title"]' };
         case 'archive-list': case 'restore-list': return rest[0] ? ['archive-list', { list: rest[0], archived: verb === 'archive-list' }] : { refused: `binder ${verb} LIST` };
-        case 'archive': case 'restore': return rest[0] ? ['archive', { id: rest[0], restore: verb === 'restore' }] : { refused: `binder ${verb} ID` };
+        case 'columns': {
+            const [list, action, ...more] = rest;
+            if (!list || !action) return { refused: 'binder columns LIST add "Name" [--after STATE|--before STATE] | binder columns LIST rename "Old" "New"' };
+            if (action === 'add') return more.length ? ['columns', { list, add: more.join(' '), ...(flags.after ? { after: flags.after } : {}), ...(flags.before ? { before: flags.before } : {}) }] : { refused: 'binder columns LIST add "Name"' };
+            if (action === 'rename') return more.length >= 2 ? ['columns', { list, rename: { from: more[0], to: more.slice(1).join(' ') } }] : { refused: 'binder columns LIST rename "Old" "New"' };
+            return { refused: 'binder columns LIST add "Name" | rename "Old" "New"' };
+        }
         default: return { refused: 'not understood' };
     }
 }

package/host/binder-host.mjs

@@ -71,7 +71,8 @@ export function say(op, data, list) {
         case 'attach': return 'Attached.';
         case 'detach': return 'Taken off.';
         case 'archive': return data.archived ? `Archived #${data.id}.` : `Restored #${data.id}.`;
-        case 'settings': case 'edit-settings': return `Lists an agent may make: ${data.agentLists}.`;
+        case 'settings': case 'edit-settings': return `Lists an agent may make: ${data.agentLists}. Columns an agent may change: ${data.agentColumns ? 'yes' : 'no'}.`;
+        case 'edit-list': case 'columns': return `The columns are set: ${(data.states ?? []).map((x) => x.name).join(', ')}.`;
         case 'create-list': return `Made the list ${data.title} [${data.id}], yours to change: binder add ${data.id} "title".`;
         case 'archive-list': return data.archived ? `Archived the list ${data.title} [${data.id}]. A person can restore or delete it.` : `Restored the list ${data.title} [${data.id}].`;
         default: return 'Done.';
@@ -104,11 +105,29 @@ export function keeper(dir, { sides = () => [], now = () => Date.now() } = {}) {
                 case 'edit-note': data = store.editNote(a.id, a.note, a.text, who); break;
                 case 'create-list': data = store.createList({ template: a.template, title: a.title, lang: a.lang }, who); break;
                 case 'edit-list': data = store.editList(a.list, { title: a.title, view: a.view, states: a.states, fields: a.fields }, who); break;
+                case 'columns': {
+                    /* Add or rename a column, keeping every other column (its id, its gate, its "done") as it is,
+                       then edit the list with the whole set -- so the gate is never worked around. */
+                    const match = (ref) => (x) => x.id === ref || x.name.toLowerCase() === String(ref ?? '').toLowerCase();
+                    const l = store.lists(who).find(match(a.list));
+                    if (!l) throw new Refused(`no list ${oneLine(a.list, 100) || '(none given)'}`);
+                    const states = l.states.map((x) => ({ id: x.id, name: x.name, ...(x.gate ? { gate: true } : {}), ...(x.done ? { done: true } : {}) }));
+                    if (a.rename) { const c = states.find(match(a.rename.from)); if (!c) throw new Refused(`no column "${a.rename.from}"`); c.name = oneLine(a.rename.to, 60); }
+                    if (a.add) {
+                        const name = oneLine(a.add, 60); if (!name) throw new Refused('a column needs a name');
+                        let at = states.length;
+                        if (a.after !== undefined) { const i = states.findIndex(match(a.after)); if (i >= 0) at = i + 1; }
+                        else if (a.before !== undefined) { const i = states.findIndex(match(a.before)); if (i >= 0) at = i; }
+                        states.splice(at, 0, { name });
+                    }
+                    data = store.editList(a.list, { states }, who);
+                    break;
+                }
                 case 'grant': data = store.grant(a.list, a.to, a.access ?? null, who); break;
                 case 'archive-list': data = store.archiveList(a.list, a.archived !== false, who); break;
                 case 'delete-list': data = store.deleteList(a.list, who); break;
                 case 'settings': data = store.settings(who); break;
-                case 'edit-settings': data = store.editSettings({ agentLists: a.agentLists }, who); break;
+                case 'edit-settings': data = store.editSettings({ agentLists: a.agentLists, agentColumns: a.agentColumns }, who); break;
                 case 'templates': data = Object.fromEntries(Object.entries(TEMPLATES).map(([k, t]) => [k, t.name])); break;
                 default: return { ok: false, text: `there is no ${oneLine(op, 40)}` };
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clavarium-binder",
-  "version": "0.1.3",
+  "version": "0.1.5-next.1",
   "description": "Clavarium Binder: lists of records kept together by people and AI agents, each with its id (a command and an MCP server for agents, a keeper and a screen for the application). No dependency.",
   "license": "MIT",
   "homepage": "https://github.com/clavarium/clavarium-binder#readme",

package/server/binder.mjs

@@ -23,7 +23,7 @@ import { fileURLToPath } from 'node:url';
 import { randomUUID } from 'node:crypto';
 import { createInterface } from 'node:readline';
 
-export const VERSION = '0.1.3';
+export const VERSION = '0.1.5-next.1';
 export const FOLDER = '.binder';
 /* How long an ask waits for its answer. The keeper answers within a second or two. */
 export const WAIT_MS = 20_000;
@@ -71,7 +71,7 @@ export const TOOLS = [
     { name: 'edit', description: 'Change a record: title, description, fields, owners, due date, lead reminder, cover picture (empty to remove it).', inputSchema: { type: 'object', properties: { id: { type: 'string' }, title: { type: 'string' }, description: DESCRIBE, due: { type: 'string' }, remindBefore: { type: 'integer', description: 'remind the owners this many days before the due time (e.g. 1, 3, 7); 0 removes it' }, owner: S('"me", or an id; empty for nobody'), fields: { type: 'object' }, cover: S('the picture the card is shown by, when it has several: a picture attached (its ref) or a photo field; empty to remove it') }, required: ['id'] } },
     { name: 'move', description: 'Put a record in another state of its list. Past a gate (an approval), only once a person approved it.', inputSchema: { type: 'object', properties: { id: { type: 'string' }, state: { type: 'string' } }, required: ['id', 'state'] } },
     { name: 'note', description: 'Add a short note to a record: a decision, a fact, a result. Talking with the person stays in the chat.', inputSchema: { type: 'object', properties: { id: { type: 'string' }, text: { type: 'string' } }, required: ['id', 'text'] } },
-    { name: 'attach', description: 'Attach something to a record: a message of the chat, a file, an asset, a branch, a link, another record.', inputSchema: { type: 'object', properties: { id: { type: 'string' }, kind: { type: 'string', enum: ['message', 'file', 'asset', 'branch', 'link', 'record'] }, ref: S('what it is: a path, a URL, repository:branch, a message id, a record number'), title: { type: 'string' } }, required: ['id', 'kind', 'ref'] } },
+    { name: 'attach', description: 'Attach something to a record: a message of the chat, a file, an asset, a branch, a commit, a link, another record.', inputSchema: { type: 'object', properties: { id: { type: 'string' }, kind: { type: 'string', enum: ['message', 'file', 'asset', 'branch', 'commit', 'link', 'record'] }, ref: S('what it is: a path, a URL, repository:branch, repository:sha, a message id, a record number'), title: { type: 'string' } }, required: ['id', 'kind', 'ref'] } },
     { name: 'detach', description: 'Take back something attached to a record.', inputSchema: { type: 'object', properties: { id: { type: 'string' }, what: S('what get shows of it: its ref or its id') }, required: ['id', 'what'] } },
     { name: 'new-list', description: 'Make a list from a template (batches, development, customers, people, roadmap, simple) when none you were given fits: it is given to you alone, and the person sees it. Batches: the work you propose; the person ticks what you may start.', inputSchema: { type: 'object', properties: { template: S('batches, development, customers, people, roadmap or simple'), title: S('its name; the template\'s by default') }, required: ['template'] } },
     { name: 'archive-list', description: 'Archive a list you made (it leaves your tabs; a person still sees it and can restore or delete it), or restore it. You cannot delete a list; only a person does. Archived lists do not count against your few-lists limit.', inputSchema: { type: 'object', properties: { list: S('its name or id'), restore: { type: 'boolean' } }, required: ['list'] } },

package/server/store.mjs

@@ -31,6 +31,10 @@ export const TITLE_MAX = 200;
 /* Lists an agent may have made and not archived: 5 until a person sets it (settings.agentLists), 0 to 50. */
 export const AGENT_LISTS_DEFAULT = 5;
 export const AGENT_LISTS_TOP = 50;
+/* Whether an agent may change a list's columns (its states): true until a person turns it off
+   (settings.agentColumns). Even on, an agent never touches the gate -- the person's approval
+   boundary -- nor removes a column: it only adds and renames, so a gate can never be worked around. */
+export const AGENT_COLUMNS_DEFAULT = true;
 /* The default, by its former name. */
 export const AGENT_LISTS_MAX = AGENT_LISTS_DEFAULT;
 export const NOTE_MAX = 2000;
@@ -45,7 +49,7 @@ export const ATTACHED_MAX = 200;
 export const STATES_MAX = 12;
 export const FIELDS_MAX = 20;
 export const OWNERS_MAX = 10;
-export const ATTACH_KINDS = ['message', 'file', 'asset', 'branch', 'link', 'record'];
+export const ATTACH_KINDS = ['message', 'file', 'asset', 'branch', 'commit', 'link', 'record'];
 /* A file attached that is a picture, by its name (the screen has the same rule). */
 export const isPicture = (ref) => /\.(jpe?g|png|webp|gif)$/i.test(String(ref ?? '').split(/[?#]/)[0]);
 
@@ -57,6 +61,33 @@ const key = (text) => oneLine(text, 40).toLowerCase().normalize('NFD').replace(/
 export class Refused extends Error {}
 const no = (why) => { throw new Refused(why); };
 
+/* An agent changing a list's columns (its states) may ADD new ones and RENAME existing ones, but
+   never remove a column, never add/remove/move the gate, and never move an existing column across
+   the gate. So the gate -- the person's approval boundary -- can never be worked around. Throws
+   (Refused) when a proposed set of states would break any of that. `have` is the list's states now. */
+function agentColumnsOk(have, proposed) {
+    if (!Array.isArray(proposed) || proposed.length < 1) no('say the columns');
+    const idOf = (st) => oneLine(st?.id, 40) || key(oneLine(st?.name, 60)) || 'state';
+    const propIds = proposed.map(idOf);
+    const propSet = new Set(propIds);
+    for (const st of have) if (!propSet.has(st.id)) no('an agent adds or renames columns, it does not remove one -- ask a person');
+    proposed.forEach((st, i) => {
+        const existing = have.find((h) => h.id === propIds[i]);
+        if (existing) { if (!!st?.gate !== !!existing.gate || !!st?.done !== !!existing.done) no('an agent does not change a column\'s gate or its "done" -- ask a person'); }
+        else if (st?.gate || st?.done) no('an agent does not add a gate or a "done" column -- ask a person');
+    });
+    const gate = have.find((x) => x.gate);
+    if (gate) {
+        const gatePos = propIds.indexOf(gate.id);
+        const haveGatePos = have.findIndex((x) => x.id === gate.id);
+        for (const st of have) {
+            if (st.id === gate.id) continue;
+            const wasBefore = have.findIndex((x) => x.id === st.id) < haveGatePos;
+            if (wasBefore !== (propIds.indexOf(st.id) < gatePos)) no('an agent does not move a column across the gate -- ask a person');
+        }
+    }
+}
+
 /* A due date: "2026-11-04" or "2026-11-04 09:00", kept as written (the keeper's clock reads it). */
 const DUE = /^\d{4}-\d{2}-\d{2}( \d{2}:\d{2})?$/;
 export const dueAt = (due) => { const t = Date.parse(due.length === 10 ? `${due}T09:00:00` : due.replace(' ', 'T')); return Number.isFinite(t) ? t : null; };
@@ -125,7 +156,7 @@ export function openStore(dir, { now = () => Date.now() } = {}) {
 
     /* Whether a record's title, description or notes hold `q` (lower case). */
     /* The store's settings, as they are now (a store from before them has the defaults). */
-    const settingsNow = () => ({ agentLists: Number.isInteger(s.settings?.agentLists) ? s.settings.agentLists : AGENT_LISTS_DEFAULT });
+    const settingsNow = () => ({ agentLists: Number.isInteger(s.settings?.agentLists) ? s.settings.agentLists : AGENT_LISTS_DEFAULT, agentColumns: typeof s.settings?.agentColumns === 'boolean' ? s.settings.agentColumns : AGENT_COLUMNS_DEFAULT });
 
     const said = (r, q) => r.title.toLowerCase().includes(q) || (r.description ?? '').toLowerCase().includes(q) || r.notes.some((n) => n.text.toLowerCase().includes(q));
 
@@ -214,8 +245,13 @@ export function openStore(dir, { now = () => Date.now() } = {}) {
         },
         editList(given, { title, view, states, fields } = {}, who) {
             const w = whoOf(who);
-            if (!isPerson(w)) no('only a person changes a list');
+            if (!isPerson(w)) {
+                /* An agent may change only the columns (states), when a person allows it, and never the gate. */
+                if (title !== undefined || view !== undefined || fields !== undefined || states === undefined) no('only a person changes a list (an agent may change its columns)');
+                if (!settingsNow().agentColumns) no('a person turned off the columns an agent may change');
+            }
             const list = listOf(given, w, 'write');
+            if (!isPerson(w)) agentColumnsOk(list.states, states);
             const change = {};
             if (title !== undefined) { const t = oneLine(title, TITLE_MAX); if (!t) no('a list needs a title'); list.title = change.title = t; }
             if (view !== undefined) { if (!VIEWS.includes(view)) no(`a view is one of: ${VIEWS.join(', ')}`); list.view = change.view = view; }
@@ -280,7 +316,7 @@ export function openStore(dir, { now = () => Date.now() } = {}) {
 
         /* ---- the store's settings: anyone reads them, a person changes them ---- */
         settings(who) { whoOf(who); return settingsNow(); },
-        editSettings({ agentLists } = {}, who) {
+        editSettings({ agentLists, agentColumns } = {}, who) {
             const w = whoOf(who);
             if (!isPerson(w)) no('only a person changes the settings');
             const change = {};
@@ -289,6 +325,10 @@ export function openStore(dir, { now = () => Date.now() } = {}) {
                 if (!Number.isInteger(n) || n < 0 || n > AGENT_LISTS_TOP) no(`lists an agent may make: a whole number from 0 to ${AGENT_LISTS_TOP}`);
                 change.agentLists = n;
             }
+            if (agentColumns !== undefined) {
+                const b = agentColumns === true || agentColumns === 'true' ? true : agentColumns === false || agentColumns === 'false' ? false : no('columns an agent may change: true or false');
+                change.agentColumns = b;
+            }
             if (!Object.keys(change).length) return settingsNow();
             s.settings = { ...s.settings, ...change };
             save(); log(w, 'edit-settings', { change });

package/ui/binder-ui.js

@@ -29,10 +29,10 @@ export const KEYS = Object.freeze(['lists', 'binder', 'new-list', 'new-item', 'n
     'states', 'fields', 'access', 'read', 'write', 'none', 'save', 'empty', 'archived', 'show-archived', 'gate', 'done', 'add-state', 'add-field',
     'kind-message', 'kind-file', 'kind-asset', 'kind-branch', 'kind-link', 'kind-record', 'what', 'name', 'type', 'saved', 'edited', 'by', 'mine', 'all',
     'delete-list', 'delete-list-sure', 'archive-list', 'no-records', 'none-archived', 'none-mine', 'search', 'description', 'edit', 'more', 'approve', 'add', 'ok',
-    'add-what', 'owner', 'attachment', 'tools', 'cover', 'agent-lists', 'remind-before', 'no-remind', 'days',
+    'add-what', 'owner', 'attachment', 'tools', 'cover', 'agent-lists', 'agent-columns', 'remind-before', 'no-remind', 'days',
     'op-add', 'op-edit', 'op-move', 'op-note', 'op-edit-note', 'op-remove-note', 'op-attach', 'op-detach', 'op-archive', 'op-restore', 'op-delete']);
-const KINDS = ['message', 'file', 'asset', 'branch', 'link', 'record'];
-const ICON = { message: '💬', file: '📄', asset: '🗄', branch: '⑂', link: '🔗', record: '▣' };
+const KINDS = ['message', 'file', 'asset', 'branch', 'commit', 'link', 'record'];
+const ICON = { message: '💬', file: '📄', asset: '🗄', branch: '⑂', commit: '◉', link: '🔗', record: '▣' };
 const TYPES = ['text', 'number', 'date', 'link', 'photo'];
 const DESCRIPTION_MAX = 4000;
 
@@ -581,6 +581,11 @@ export function mount(root, { call, words = {}, lang = 'en', people = () => [],
             n.addEventListener('change', () => void soft(ask('edit-settings', { agentLists: n.value })).then((got) => { if (got) ui.settings = got; paint(); }));
             return n;
         }
+        function agentColumns() {
+            const c = h('input', { type: 'checkbox', ...(ui.settings.agentColumns ? { checked: true } : {}), 'data-setting': 'agentColumns' });
+            c.addEventListener('change', () => void soft(ask('edit-settings', { agentColumns: c.checked })).then((got) => { if (got) ui.settings = got; paint(); }));
+            return h('label', { class: 'binder-toggle' }, c, h('span', {}, w('agent-columns')));
+        }
         return h('div', { class: 'binder-page binder-settings' },
             h('div', { class: 'binder-crumb' }, backButton(l.title)),
             h('section', { class: 'binder-box' }, h('h3', {}, w('title')), title),
@@ -588,6 +593,7 @@ export function mount(root, { call, words = {}, lang = 'en', people = () => [],
             h('section', { class: 'binder-box' }, h('h3', {}, w('fields')), fieldRows),
             grants.length ? h('section', { class: 'binder-box' }, h('h3', {}, w('access')), grants) : null,
             ui.settings ? h('section', { class: 'binder-box' }, h('h3', {}, w('agent-lists')), agentLists()) : null,
+            ui.settings ? h('section', { class: 'binder-box' }, h('h3', {}, w('agent-columns')), agentColumns()) : null,
             h('div', { class: 'binder-actions' },
                 h('button', { type: 'button', class: 'binder-ghost', onclick: () => void soft(ask('archive-list', { list: l.id })).then(() => { ui.mode = 'list'; ui.at = null; return refresh(); }) }, w('archive-list')),
                 h('button', { type: 'button', class: 'binder-ghost', onclick: () => { sure.hidden = false; } }, w('delete-list')), sure,

package/ui/texts/en.json

@@ -47,6 +47,7 @@
   "kind-file": "File",
   "kind-asset": "Asset",
   "kind-branch": "Branch",
+  "kind-commit": "Commit",
   "kind-link": "Link",
   "kind-record": "Card",
   "what": "What",
@@ -76,6 +77,7 @@
   "tools": "More",
   "cover": "Cover",
   "agent-lists": "Lists an agent may make",
+  "agent-columns": "An agent may change the columns",
   "op-add": "Created",
   "op-edit": "Edited",
   "op-move": "Moved",

package/ui/texts/fr.json

@@ -47,6 +47,7 @@
   "kind-file": "Fichier",
   "kind-asset": "Asset",
   "kind-branch": "Branche",
+  "kind-commit": "Commit",
   "kind-link": "Lien",
   "kind-record": "Fiche",
   "what": "Quoi",
@@ -76,6 +77,7 @@
   "tools": "Plus",
   "cover": "À la une",
   "agent-lists": "Classeurs qu'une IA peut créer",
+  "agent-columns": "Une IA peut changer les colonnes",
   "op-add": "Créée",
   "op-edit": "Modifiée",
   "op-move": "Déplacée",