sideby 0.13.1 → 0.15.0

package/dist/src/panel/page-logic.js

@@ -44,14 +44,16 @@ export function quotaPressure(a, now) {
     const q = a.quota;
     if (q?.status !== 'ok' || !q.windows)
         return -1;
+    // A named window covers only some models and never counts (spec §3.26).
+    const windows = q.windows.filter((w) => !w.name);
     let max = -1;
-    for (const w of q.windows) {
+    for (const w of windows) {
         const reset = Date.parse(w.resetsAt);
         if (Number.isFinite(reset) && reset <= now)
             continue;
         max = Math.max(max, Math.max(0, Math.min(100, Number(w.usedPercent) || 0)));
     }
-    return q.windows.length && max < 0 ? 0 : max;
+    return windows.length && max < 0 ? 0 : max;
 }
 /**
  * Why an Account needs a look, most serious first: `error`, `health-fail`, `signed-out`, `not-installed`,
@@ -71,6 +73,8 @@ export function attentionReasons(a, health, now, warn) {
     const q = a.quota;
     if (q && q.status === 'ok' && q.windows && !q.from)
         for (const w of q.windows) {
+            if (w.name)
+                continue;
             const reset = Date.parse(w.resetsAt);
             if (Number.isFinite(reset) && reset <= now)
                 continue;
@@ -96,6 +100,8 @@ export function attentionWhy(a, health, now, warn) {
         return { key: `why.${reason}`, vars: {} };
     let top = null;
     for (const w of a.quota?.windows ?? []) {
+        if (w.name)
+            continue;
         const reset = Date.parse(w.resetsAt);
         if (Number.isFinite(reset) && reset <= now)
             continue;
@@ -105,16 +111,55 @@ export function attentionWhy(a, health, now, warn) {
     }
     return { key: 'why.quota-high', vars: { label: top?.label ?? '', pct: Math.round(top?.pct ?? 0), warn } };
 }
-/** Sorted copy: `pressure` (fullest Quota first), `name`, or `recent` (last activity first). The Main Account leads ties. */
-export function sortAccounts(list, mode, now) {
+/**
+ * `items` in Display Order (spec §3.25): those whose key is in `order` first, in that order; the others after, in the
+ * order they came. Names no longer there are simply not met.
+ */
+export function inDisplayOrder(items, key, order) {
+    const at = new Map((order ?? []).map((k, i) => [k, i]));
+    return items
+        .map((t, i) => ({ t, i, r: at.has(key(t)) ? at.get(key(t)) : (order?.length ?? 0) }))
+        .sort((x, y) => x.r - y.r || x.i - y.i)
+        .map((x) => x.t);
+}
+/**
+ * The Display Order after a drag (spec §3.25). `all` is every key of the list in the current Display Order, hidden
+ * ones included; `shown` is what the screen showed, in its order, as units (one key, or a Same Login group that moves
+ * as one). The unit at `from` moves to `to`; the shown keys then fill the places shown keys held in `all`, so keys a
+ * filter hides keep their place among themselves.
+ */
+export function reorder(all, shown, from, to) {
+    const units = shown.slice();
+    if (from < 0 || from >= units.length || to < 0 || to >= units.length)
+        return all.slice();
+    const [unit] = units.splice(from, 1);
+    units.splice(to, 0, unit);
+    const next = units.flat();
+    const visible = new Set(next);
+    const out = all.slice();
+    for (const k of next)
+        if (!out.includes(k))
+            out.push(k);
+    let i = 0;
+    for (let at = 0; at < out.length; at++)
+        if (visible.has(out[at]))
+            out[at] = next[i++];
+    return out;
+}
+/**
+ * Sorted copy: `pressure` (fullest Quota first), `name`, `recent` (last activity first), or `manual` (the Family's
+ * Display Order `order`, names not in it after). The Main Account leads ties.
+ */
+export function sortAccounts(list, mode, now, order) {
     const byName = (x, y) => Number(Boolean(y.isMain)) - Number(Boolean(x.isMain)) ||
         x.name.localeCompare(y.name, undefined, { numeric: true });
     const pressure = (a) => {
         const q = a.quota;
         if (q?.status !== 'ok' || !q.windows)
             return -1;
-        let max = q.windows.length ? 0 : -1;
-        for (const w of q.windows) {
+        const windows = q.windows.filter((w) => !w.name);
+        let max = windows.length ? 0 : -1;
+        for (const w of windows) {
             const reset = Date.parse(w.resetsAt);
             if (!(Number.isFinite(reset) && reset <= now))
                 max = Math.max(max, Number(w.usedPercent) || 0);
@@ -128,12 +173,35 @@ export function sortAccounts(list, mode, now) {
     const out = list.slice();
     if (mode === 'name')
         out.sort(byName);
+    else if (mode === 'manual')
+        return inDisplayOrder(out.sort(byName), (a) => a.name, order);
     else if (mode === 'recent')
         out.sort((x, y) => last(y) - last(x) || byName(x, y));
     else
         out.sort((x, y) => pressure(y) - pressure(x) || byName(x, y));
     return out;
 }
+/**
+ * Whether an Account is pinned (spec §3.25): its name is in `pinned`, or, for a Same Login, the name of any of its
+ * directories, so the login is pinned as a whole.
+ */
+export function pinnedIn(a, pinned) {
+    return (pinned.includes(a.name) || (a.sameLogin ?? []).some((r) => pinned.includes(r.slice(r.indexOf(':') + 1))));
+}
+/**
+ * Pinned Accounts first (spec §3.25): the names in `pinned`, in that order, then the rest in the order they came.
+ * A Same Login follows any of its pinned directories, so it stays together. Names no longer there are simply not met.
+ */
+export function withPinned(list, pinned) {
+    if (!pinned?.length)
+        return list.slice();
+    const top = [];
+    for (const n of pinned)
+        for (const a of list)
+            if (!top.includes(a) && pinnedIn(a, [n]))
+                top.push(a);
+    return top.concat(list.filter((a) => !top.includes(a)));
+}
 /**
  * The sorted list with each Same Login together (spec §3.21): an Account, or the shown members of one login, in
  * order, at the place of its first member. A login with one shown member stays a plain Account.
@@ -289,6 +357,31 @@ export function panelHint(hint, fixable, action) {
         return hint;
     return hint.replace(/run `sideby doctor --fix`/g, (_m, at) => at === 0 ? action.charAt(0).toUpperCase() + action.slice(1) : action);
 }
+/**
+ * Whether the Panel fixes Finding `f` with a button of its own: a sideby skill behind this version while the
+ * Update plan says sideby may update it (`skillUpdatable`). Such Findings stay out of the prompt for an AI agent.
+ */
+export function panelFixes(f, skillUpdatable) {
+    return skillUpdatable && f.code === 'skill.outdated';
+}
+/**
+ * The prompt "Copy for AI" puts on the clipboard: `words.lead`, then each Finding that has no automatic fix
+ * (numbered, with its account, item, level, message and hint), then `words.fixFirst` when some Findings do have
+ * one, then `words.check`. Empty when every Finding has an automatic fix. `words.hint` labels a hint line.
+ */
+export function fixPrompt(findings, words) {
+    const manual = findings.filter((f) => !f.fixable);
+    if (!manual.length)
+        return '';
+    const items = manual.map((f, i) => {
+        const lines = [i + 1 + '. [' + f.level + '] ' + f.account + ' · ' + f.item, '   ' + f.message];
+        if (f.hint)
+            lines.push('   ' + words.hint + f.hint);
+        return lines.join('\n');
+    });
+    const tail = manual.length < findings.length ? [words.fixFirst, words.check] : [words.check];
+    return [words.lead, items.join('\n\n'), ...tail].join('\n\n');
+}
 /**
  * A short command to offer for a new Account `name` of a Family, from the config aliases of its existing Accounts:
  * an alias that is a prefix plus its Account's name (`cc001` for `claude:001`) gives the prefix, the most common