From c655e46dbff8cf6da18a49318e70c04bb4ec9de1 Mon Sep 17 00:00:00 2001 From: Factor Date: Thu, 19 Nov 2026 11:31:37 +0100 Subject: [PATCH] feat: history and favorites model Co-Authored-By: Ovis Fast (Claude) --- mod/ovis-composer/history.js | 143 +++++++++++++++++++++++++++++++++++ mod/ovis-composer/main.js | 44 ++++++++++- mod/ovis-composer/storage.js | 83 ++++++++++++++------ tests/history.test.mjs | 108 ++++++++++++++++++++++++++ 4 files changed, 353 insertions(+), 25 deletions(-) create mode 100644 mod/ovis-composer/history.js create mode 100644 tests/history.test.mjs diff --git a/mod/ovis-composer/history.js b/mod/ovis-composer/history.js new file mode 100644 index 0000000..bc8f0e1 --- /dev/null +++ b/mod/ovis-composer/history.js @@ -0,0 +1,143 @@ +// history.js - the model of the history and the favourites. +// +// Pure: no GPUI, no herdr, no IO. Every function returns a new list and never +// touches the one it was given. What is kept on the disk is storage.js; the +// panel that shows it is Task 7. + +import { HISTORY_LIMIT, FAVORITES_LIMIT } from "./storage.js"; + +/** + * @typedef {object} HistoryEntry + * @property {string} id + * @property {string} text + * @property {number} sentAt + * @property {string} agent - the address of the agent (`t2`) + * @property {string} agentName + * @property {string} space + * @property {string} spaceName + * @property {string} [tabName] + * + * @typedef {object} Favorite + * @property {string} id + * @property {string} text + * @property {number} createdAt + * + * @typedef {object} Hit + * @property {HistoryEntry|Favorite} item + * @property {[number, number][]} ranges - where the query was found: [start, end) + */ + +/** + * A message was sent: it goes to the end of the history. + * + * Duplicates are kept - the same text sent twice is two entries. The oldest + * entries drop out over the limit (500). + * + * @param {HistoryEntry[]} list - chronological, the oldest first + * @param {HistoryEntry} entry + * @returns {HistoryEntry[]} + */ +export function record(list, entry) { + return [...(Array.isArray(list) ? list : []), entry].slice(-HISTORY_LIMIT); +} + +/** + * What matches the query - newest first. + * + * The query is a fragment, found without regard to case (Polish letters too), + * every occurrence. An empty query (or one of spaces only) gives everything. + * + * @param {(HistoryEntry|Favorite)[]} list + * @param {string} query + * @returns {Hit[]} + */ +export function search(list, query) { + const needle = fold(String(query ?? "").trim()); + const items = (Array.isArray(list) ? list : []) + .map((item, index) => ({ item, index })) + .sort((a, b) => momentOf(b.item) - momentOf(a.item) || b.index - a.index); + + if (needle === "") return items.map(({ item }) => ({ item, ranges: [] })); + + const hits = []; + for (const { item } of items) { + const ranges = occurrences(fold(String(item.text ?? "")), needle); + if (ranges.length > 0) hits.push({ item, ranges }); + } + return hits; +} + +/** + * The favourite is added, or removed when it is there already. Texts are + * compared after `trim()`; the oldest favourites drop out over the limit + * (100). Nothing but spaces is not a favourite - the same list comes back. + * + * @param {Favorite[]} favs + * @param {string} text + * @param {number} now + * @returns {Favorite[]} + */ +export function toggleFavorite(favs, text, now) { + const list = Array.isArray(favs) ? favs : []; + const clean = String(text ?? "").trim(); + if (clean === "") return favs; + + if (list.some((fav) => fav.text.trim() === clean)) { + return list.filter((fav) => fav.text.trim() !== clean); + } + return [...list, { id: freshId(list, now), text: clean, createdAt: now }].slice(-FAVORITES_LIMIT); +} + +/** + * @param {Favorite[]} favs + * @param {string} text + * @returns {boolean} + */ +export function isFavorite(favs, text) { + const clean = String(text ?? "").trim(); + if (clean === "") return false; + return (Array.isArray(favs) ? favs : []).some((fav) => fav.text.trim() === clean); +} + +/** The moment an entry was made - a history entry or a favourite. */ +function momentOf(item) { + const value = item.sentAt ?? item.createdAt; + return Number.isFinite(value) ? value : 0; +} + +/** + * The text in the form the comparison uses: every letter in lower case, one + * character for one character - so a position in the folded text is a position + * in the original (a letter that would change the length stays as it is). + */ +function fold(text) { + return text + .split("") + .map((char) => { + const lower = char.toLowerCase(); + return lower.length === 1 ? lower : char; + }) + .join(""); +} + +/** Where `needle` is in `text`: every place, none overlapping. */ +function occurrences(text, needle) { + const ranges = []; + let from = 0; + for (;;) { + const at = text.indexOf(needle, from); + if (at < 0) break; + ranges.push([at, at + needle.length]); + from = at + needle.length; + } + return ranges; +} + +/** An id that no favourite has yet. */ +function freshId(list, now) { + const taken = new Set(list.map((fav) => fav.id)); + let n = 0; + let id = `f${now}`; + while (taken.has(id)) id = `f${now}-${(n += 1)}`; + return id; +} diff --git a/mod/ovis-composer/main.js b/mod/ovis-composer/main.js index b7095ab..8fc688b 100644 --- a/mod/ovis-composer/main.js +++ b/mod/ovis-composer/main.js @@ -41,6 +41,7 @@ import { detect as detectTrigger, rank, merge, startsLine } from "./suggest.js"; import * as catalog from "./catalog.js"; import { LIMITS, validateMany, mention, removeMention } from "./attachments.js"; import * as storage from "./storage.js"; +import { record } from "./history.js"; import { agentKey, agentName, @@ -87,6 +88,11 @@ export default class Composer extends View { this.state = createState(); this.store = guardedStore({ get: shared, set: setShared }); + // The one place every send of a message passes: the direct send, the + // queue, the countdown and "Wyślij teraz" all call `hc send` through it, + // so the history gets exactly one entry per send that `hc` accepted. + this.sendHc = (args) => this.runSend(args); + // Per agent: the turn gate, whether a drain is in flight, and whether the // queue of that agent was read from the disk. this.gates = new Map(); @@ -736,7 +742,7 @@ export default class Composer extends View { this.persistQueue(key); try { - const result = await sendToTerminal({ terminal: agent.address, hc }, message); + const result = await sendToTerminal({ terminal: agent.address, hc: this.sendHc }, message); if (result.ok) { this.state = reduce(this.state, { type: "settle", agent: key, id, outcome: "sent" }); this.persistQueue(key); @@ -892,7 +898,7 @@ export default class Composer extends View { { agent: key, terminal: agent.address, - hc, + hc: this.sendHc, status: () => this.statusOf(agent), // One message per turn: after the first send the gate is shut. gate: () => !sent && gatePasses(this.gateFor(key), this.statusOf(agent)), @@ -997,7 +1003,7 @@ export default class Composer extends View { this.persistQueue(key); try { - const result = await sendToTerminal({ terminal: agent.address, hc }, item.text); + const result = await sendToTerminal({ terminal: agent.address, hc: this.sendHc }, item.text); if (result.ok) { this.state = reduce(this.state, { type: "settle", agent: key, id, outcome: "sent" }); this.persistQueue(key); @@ -1294,6 +1300,38 @@ export default class Composer extends View { // --- the state on the disk ----------------------------------------------- + /** + * `hc` for the sends: runs the call and, when it was a `send` that `hc` + * accepted (exit code 0 and no "error" in the JSON - `hcOk`), writes the + * message into the history. A history that cannot be written does not + * change the result of the send. + */ + async runSend(args) { + const res = await hc(args); + if (args[0] === "send" && hcOk(res)) this.recordSent(String(args[1]), String(args[2] ?? "")); + return res; + } + + /** The history gets the message that went to the terminal. */ + recordSent(address, text) { + try { + const agent = liveAgents().find((entry) => entry.address === address); + const entry = { + id: this.newId(), + text, + sentAt: Date.now(), + agent: address, + agentName: agent ? agentName(agent) : "", + space: agent?.space ?? "", + spaceName: agent?.space_name ?? "", + tabName: agent?.tab_name ?? "", + }; + storage.saveHistory(this.store, record(storage.loadHistory(this.store), entry)); + } catch (err) { + this.notice(`Nie udało się zapisać historii: ${errorText(err)}`, "error"); + } + } + /** The queue of an agent goes to the disk at once - a crash must not send a message twice. */ persistQueue(key) { try { diff --git a/mod/ovis-composer/storage.js b/mod/ovis-composer/storage.js index 4a14360..34006dd 100644 --- a/mod/ovis-composer/storage.js +++ b/mod/ovis-composer/storage.js @@ -35,22 +35,17 @@ * @typedef {object} HistoryEntry * @property {string} id * @property {string} text - * @property {number} at + * @property {number} sentAt * @property {string} agent + * @property {string} agentName * @property {string} space * @property {string} spaceName - * @property {string} tab - * @property {string} pane - * @property {string|null} machine - * @property {string[]} attachments - * @property {"sent"|"queued"|"failed"} outcome + * @property {string} [tabName] * * @typedef {object} FavoriteEntry * @property {string} id * @property {string} text - * @property {number} at - * @property {string} agent - * @property {"history"|"manual"} source + * @property {number} createdAt * * @typedef {object} QueueEntry * @property {string} id @@ -101,7 +96,7 @@ export function queueKey(agent) { * @returns {HistoryEntry[]} */ export function loadHistory(store) { - return readList(store, KEYS.history, HISTORY_LIMIT, isTextEntry); + return readList(store, KEYS.history, HISTORY_LIMIT, isHistoryEntry, toHistoryEntry); } /** @@ -110,7 +105,7 @@ export function loadHistory(store) { * @returns {void} */ export function saveHistory(store, items) { - writeList(store, KEYS.history, items, HISTORY_LIMIT, isTextEntry); + writeList(store, KEYS.history, items, HISTORY_LIMIT, isHistoryEntry, toHistoryEntry); } /** @@ -121,7 +116,7 @@ export function saveHistory(store, items) { * @returns {FavoriteEntry[]} */ export function loadFavorites(store) { - return readList(store, KEYS.favorites, FAVORITES_LIMIT, isTextEntry); + return readList(store, KEYS.favorites, FAVORITES_LIMIT, isFavoriteEntry, toFavoriteEntry); } /** @@ -130,7 +125,7 @@ export function loadFavorites(store) { * @returns {void} */ export function saveFavorites(store, items) { - writeList(store, KEYS.favorites, items, FAVORITES_LIMIT, isTextEntry); + writeList(store, KEYS.favorites, items, FAVORITES_LIMIT, isFavoriteEntry, toFavoriteEntry); } /** @@ -302,11 +297,14 @@ export function saveUsage(store, counts) { * @param {string} key * @param {number} limit - 0 for a list without a limit * @param {(entry:Record) => boolean} isValid + * @param {(entry:any) => any} [shape] - the entry in the shape the composer + * uses today (an old entry gets what it lacks) * @returns {any[]} */ -function readList(store, key, limit, isValid) { - const list = toList(read(store, key), isValid); - if (!list) return []; +function readList(store, key, limit, isValid, shape) { + const found = toList(read(store, key), isValid); + if (!found) return []; + const list = shape ? found.map(shape) : found; return limit > 0 ? list.slice(-limit) : list; } @@ -318,14 +316,16 @@ function readList(store, key, limit, isValid) { * @param {unknown} items * @param {number} limit - 0 for a list without a limit * @param {(entry:Record) => boolean} isValid + * @param {(entry:any) => any} [shape] * @returns {void} */ -function writeList(store, key, items, limit, isValid) { +function writeList(store, key, items, limit, isValid, shape) { const source = listSource(items); // Rubbish in - nothing is written, so the stored list stays as it was. if (!source) return; - const list = toList(source, isValid) ?? []; + const valid = toList(source, isValid) ?? []; + const list = shape ? valid.map(shape) : valid; // A list that lost every entry is rubbish, not an empty list - writing it // would wipe what is there. if (source.length > 0 && list.length === 0) return; @@ -366,14 +366,53 @@ function isEntry(entry, isValid) { } /** - * An entry the view can show - a history entry and a favourite have the same - * shape: a text and a moment. + * A history entry the view can show: a text and the moment it was sent. + * Entries from before the panel have the moment in `at`. * * @param {Record} entry * @returns {boolean} */ -function isTextEntry(entry) { - return isText(entry.id) && isText(entry.text) && isTime(entry.at); +function isHistoryEntry(entry) { + return isText(entry.id) && isText(entry.text) && (isTime(entry.sentAt) || isTime(entry.at)); +} + +/** + * A favourite the view can show: a text and the moment it was marked + * (`createdAt`, or `at` in the older entries). + * + * @param {Record} entry + * @returns {boolean} + */ +function isFavoriteEntry(entry) { + return isText(entry.id) && isText(entry.text) && (isTime(entry.createdAt) || isTime(entry.at)); +} + +/** + * The history entry as it is kept today. An old entry lacks the names of the + * agent and the space - they become empty texts, and `at` becomes `sentAt`. + * + * @param {any} entry + * @returns {object} + */ +function toHistoryEntry(entry) { + const { at, ...rest } = entry; + return { + ...rest, + sentAt: isTime(entry.sentAt) ? entry.sentAt : at, + agent: isText(entry.agent) ? entry.agent : "", + agentName: isText(entry.agentName) ? entry.agentName : "", + space: isText(entry.space) ? entry.space : "", + spaceName: isText(entry.spaceName) ? entry.spaceName : "", + }; +} + +/** + * @param {any} entry + * @returns {object} + */ +function toFavoriteEntry(entry) { + const { at, ...rest } = entry; + return { ...rest, createdAt: isTime(entry.createdAt) ? entry.createdAt : at }; } /** diff --git a/tests/history.test.mjs b/tests/history.test.mjs new file mode 100644 index 0000000..77147fe --- /dev/null +++ b/tests/history.test.mjs @@ -0,0 +1,108 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { record, search, toggleFavorite, isFavorite } from "../mod/ovis-composer/history.js"; +import { loadHistory, saveHistory, loadFavorites, saveFavorites, KEYS } from "../mod/ovis-composer/storage.js"; + +const memStore = () => { + const m = new Map(); + return { get: (k) => m.get(k), set: (k, v) => void m.set(k, v) }; +}; +const entry = (i, text = `t${i}`, over = {}) => ({ + id: `h${i}`, text, sentAt: i, agent: "t2", agentName: "claude-code", space: "s1", spaceName: "herdr", ...over, +}); + +test("record keeps duplicates", () => { + let list = record([], entry(1, "same")); + list = record(list, entry(2, "same")); + assert.equal(list.length, 2); + assert.deepEqual(list.map((e) => e.id), ["h1", "h2"]); +}); + +test("record keeps 500, the oldest drop out, and does not mutate", () => { + let list = []; + for (let i = 0; i < 500; i++) list.push(entry(i)); + const before = list.length; + const out = record(list, entry(500)); + assert.equal(list.length, before); + assert.equal(out.length, 500); + assert.equal(out[0].id, "h1"); + assert.equal(out[499].id, "h500"); +}); + +test("search is case-insensitive and returns ranges", () => { + const out = search([entry(1, "uruchom testy")], "TEST"); + assert.equal(out.length, 1); + assert.deepEqual(out[0].ranges, [[8, 12]]); + assert.equal(out[0].item.text, "uruchom testy"); +}); + +test("search finds every occurrence", () => { + const out = search([entry(1, "test a test")], "test"); + assert.deepEqual(out[0].ranges, [[0, 4], [7, 11]]); +}); + +test("search folds Polish letters by case", () => { + assert.equal(search([entry(1, "jedziemy do łódź")], "ŁÓDŹ").length, 1); + assert.equal(search([entry(1, "JEDZIEMY DO ŁÓDŹ")], "łódź").length, 1); + assert.deepEqual(search([entry(1, "do ŁÓDŹ")], "łódź")[0].ranges, [[3, 7]]); +}); + +test("search: newest first; empty query gives everything; no match gives nothing", () => { + const list = [entry(1, "a"), entry(3, "b"), entry(2, "c")]; + assert.deepEqual(search(list, "").map((r) => r.item.id), ["h3", "h2", "h1"]); + assert.deepEqual(search(list, " ").map((r) => r.item.id), ["h3", "h2", "h1"]); + assert.deepEqual(search(list, "").map((r) => r.ranges), [[], [], []]); + assert.deepEqual(search(list, "zzz"), []); + assert.deepEqual(search([], "x"), []); +}); + +test("search orders favourites by createdAt", () => { + const favs = [{ id: "a", text: "x", createdAt: 1 }, { id: "b", text: "x2", createdAt: 5 }]; + assert.deepEqual(search(favs, "x").map((r) => r.item.id), ["b", "a"]); +}); + +test("toggleFavorite adds by trimmed text, removes on a second toggle", () => { + let favs = toggleFavorite([], " hello ", 10); + assert.equal(favs.length, 1); + assert.equal(favs[0].text, "hello"); + assert.equal(favs[0].createdAt, 10); + assert.equal(isFavorite(favs, "hello "), true); + favs = toggleFavorite(favs, "hello", 20); + assert.deepEqual(favs, []); + assert.equal(isFavorite(favs, "hello"), false); +}); + +test("toggleFavorite: empty text changes nothing; limit 100 drops the oldest; ids are unique", () => { + const empty = []; + assert.equal(toggleFavorite(empty, " ", 1), empty); + let favs = []; + for (let i = 0; i < 101; i++) favs = toggleFavorite(favs, `f${i}`, 1000); + assert.equal(favs.length, 100); + assert.equal(favs[0].text, "f1"); + assert.equal(new Set(favs.map((f) => f.id)).size, 100); +}); + +test("storage: old history entries load with empty space/agentName", () => { + const store = memStore(); + store.set(KEYS.history, [{ id: "a", text: "old", at: 7, agent: "t2" }]); + const [e] = loadHistory(store); + assert.equal(e.sentAt, 7); + assert.equal(e.agentName, ""); + assert.equal(e.space, ""); + assert.equal(e.spaceName, ""); +}); + +test("storage: history and favourites roundtrip in the new shape", () => { + const store = memStore(); + saveHistory(store, [entry(1)]); + assert.deepEqual(loadHistory(store), [entry(1)]); + const fav = { id: "f", text: "x", createdAt: 3 }; + saveFavorites(store, [fav]); + assert.deepEqual(loadFavorites(store), [fav]); +}); + +test("storage: old favourites (at) load as createdAt", () => { + const store = memStore(); + store.set(KEYS.favorites, [{ id: "f", text: "x", at: 4 }]); + assert.equal(loadFavorites(store)[0].createdAt, 4); +});