synabun 2.0.0-beta → 2.0.5

package/neural-interface/public/shared/settings/settings-rules.js

@@ -0,0 +1,160 @@
+// ═══════════════════════════════════════════
+// SETTINGS — SynaBun rules, in words
+// ═══════════════════════════════════════════
+//
+// What the rules status (GET /api/setup/rules, lib/rulesets/installer.js) says about a tool: the name of its
+// state, the action that state calls for, the sentence next to it, and what an install answered. Pure: no DOM
+// and no import, so node runs it (tests/rulesets-rules-view.test.mjs).
+//
+// Two surfaces render the status, Settings → AI connections (ui-settings.js) and the onboarding wizard
+// (onboarding.html). Both ask this module, so a state reads the same and offers the same action in both.
+//
+//   describeRulesHost(info, { label, version, tx })     one tool: badge, path, action, note
+//   describeRulesInstall(result, state, { label, tx })  what Install / Update / Replace answered
+//   describeRulesInstallAll(result, { tx, labels })     what "install for all" answered, and where the rules live
+//   rulesInstallPlan(status)                            what "install for all" would find to do
+//   describeRulesInPlace(status, { tx, labels })        the same report for rules that are already there
+//   catalogueTranslator(messages)                       `tx` for a page that does not run the app's i18n
+//
+// `tx(key, params)` is the caller's translate function over the settings.redesign.setup.* strings (the kit's
+// `tx` in Settings; the wizard reads the same catalogue, i18n/en.json).
+
+/** The tools SynaBun installs rules for, in the order both surfaces list them. Cursor is copy-only. */
+export const RULES_INSTALL_HOSTS = Object.freeze(['claude', 'gemini', 'codex', 'opencode']);
+
+export const RULES_HOST_LABELS = Object.freeze({ claude: 'Claude Code', codex: 'Codex', opencode: 'OpenCode', gemini: 'Gemini', cursor: 'Cursor', coexistence: 'coexistence' });
+
+/** The states that count as "the rules are in place". `shadowed` is installed too, only not loaded (Codex's override file). */
+export const RULES_IN_PLACE = Object.freeze(['installed', 'newer', 'shadowed']);
+
+/**
+ * One tool's rules as both surfaces show them.
+ *
+ * `info` is `status.hosts[host]`, or nothing when the status could not be read (a server that was not restarted
+ * after the update answers 404): then the badge says "Unavailable", the path line says what to do and no action
+ * is offered, because none could work.
+ *
+ * @returns {{ known: boolean, state: string, badge: string, good: boolean, path: string, pathText: string,
+ *   action: ''|'install'|'update'|'replace', actionLabel: string, force: boolean, removable: boolean, note: string }}
+ */
+export function describeRulesHost(info, { label, version = null, tx }) {
+  if (!info) {
+    return {
+      known: false, state: '', badge: tx('settings.redesign.setup.unavailable'), good: false, path: '',
+      pathText: tx('settings.redesign.setup.restartSynabunToFinishThisUpdate'), action: '', actionLabel: '', force: false, removable: false, note: '',
+    };
+  }
+  const badges = {
+    installed: [tx('settings.redesign.setup.installed'), true], newer: [tx('settings.redesign.setup.newer'), true], outdated: [tx('settings.redesign.setup.updateAvailable'), false], modified: [tx('settings.redesign.setup.edited2'), false],
+    conflict: [tx('settings.redesign.setup.conflict'), false], error: [tx('settings.redesign.setup.error'), false], shadowed: [tx('settings.redesign.setup.shadowed'), false],
+    'not-installed': [tx('settings.redesign.setup.notInstalled'), false], manual: [tx('settings.redesign.setup.copyOnly'), false],
+  };
+  const [badge, good] = badges[info.state] || [info.state || tx('settings.redesign.setup.unknown'), false];
+  // The action the state calls for; conflict, error and shadowed only explain themselves.
+  const actions = { 'not-installed': ['install', tx('settings.redesign.setup.install')], outdated: ['update', tx('settings.redesign.setup.update')], modified: ['replace', tx('settings.redesign.setup.replace')] };
+  const [action, actionLabel] = info.detected === false ? ['', ''] : (actions[info.state] || ['', '']);
+  // A file without SynaBun's markers is the user's own: the server refuses to replace it, so no button.
+  const canAct = !!action && info.replaceable !== false;
+  // An edited copy is the user's: nothing replaces or removes it without the confirm behind each button.
+  const editedNote = tx('settings.redesign.setup.thisCopyWasEditedSoSynabun');
+  const stateNote = info.detected === false ? tx('settings.redesign.setup.wasNotFoundOnThisMachine', { label })
+    : info.state === 'modified' ? (info.replaceable === false ? (info.detail || '') : editedNote)
+    : info.state === 'outdated' ? (version ? tx('settings.redesign.setup.versionOfTheRulesIsAvailable', { version }) : tx('settings.redesign.setup.aNewerVersionOfTheRules'))
+    : ['conflict', 'error', 'shadowed', 'newer'].includes(info.state) ? (info.error || info.detail || '')
+    : '';
+  // A removal that could not finish left rules behind: say which, until a remove or an install completes.
+  const partial = info.partialRemoval?.error ? tx('settings.redesign.setup.theLastRemovalDidNotFinish', { error: info.partialRemoval.error }) : '';
+  const note = partial && stateNote && !partial.includes(stateNote) ? `${partial} ${stateNote}` : (partial || stateNote);
+  return {
+    known: true,
+    state: info.state || '',
+    badge,
+    good,
+    path: info.path || '',
+    pathText: info.installedVersion ? `${info.path} (v${info.installedVersion})` : (info.path || ''),
+    action: canAct ? action : '',
+    actionLabel: canAct ? actionLabel : '',
+    // Replace sends force, and only after the confirm that says the edited copy is backed up first.
+    force: canAct && action === 'replace',
+    removable: ['installed', 'newer', 'outdated', 'modified', 'shadowed'].includes(info.state),
+    note,
+  };
+}
+
+/** The sentence for what one tool's Install, Update or Replace answered. `state` is what the tool was in before. */
+export function describeRulesInstall(result, state, { label, tx }) {
+  if (!result?.changed) return tx('settings.redesign.setup.rulesAreAlreadyCurrent', { label });
+  return tx(state === 'not-installed' ? 'settings.redesign.setup.rulesInstalled2' : 'settings.redesign.setup.rulesUpdated2', { label });
+}
+
+/**
+ * What "install for all" answered: `message` is the result in one sentence, `note` says which file each tool
+ * reads ('' when nothing was written or found), `failed` lists the tools that were refused.
+ * The rules are global, so a project's own CLAUDE.md and AGENTS.md stay as they are; the note says so.
+ */
+export function describeRulesInstallAll(result, { tx, labels = RULES_HOST_LABELS }) {
+  const name = (host) => labels[host] || RULES_HOST_LABELS[host] || host;
+  const rows = Object.entries(result?.results || {});
+  if (!rows.length) return { message: tx('settings.redesign.setup.noConnectedToolNeedsRules'), note: '', failed: [] };
+  const where = rows.filter(([, row]) => row.ok !== false && row.path).map(([host, row]) => `${name(host)}: ${row.path}`).join(' · ');
+  const note = where ? tx('settings.redesign.setup.rulesInstalledAt', { where }) : '';
+  const failed = rows.filter(([, row]) => row.ok === false);
+  if (failed.length) {
+    return {
+      message: tx('settings.redesign.setup.installedWithFailure', { count: rows.length - failed.length, host: name(failed[0][0]), error: failed[0][1].error || failed[0][1].state }),
+      note,
+      failed: failed.map(([host]) => host),
+    };
+  }
+  const map = rows.map(([host]) => name(host)).join(', ');
+  return { message: tx(rows.some(([, row]) => row.changed) ? 'settings.redesign.setup.rulesInstalledFor' : 'settings.redesign.setup.rulesAlreadyCurrentFor', { map }), note, failed: [] };
+}
+
+/**
+ * What "install for all" would find to do, by the installer's own rule (installAll in lib/rulesets/installer.js):
+ * it takes a tool that is on this machine, connected to SynaBun (or already managed), not opted out and not in
+ * the middle of a removal.
+ *
+ *   pending    tools it would install or update
+ *   inPlace    tools whose rules are there already
+ *   attention  tools it would be refused for (an edited copy, damaged markers, an error): each needs its own answer
+ *   skipped    connected tools it leaves alone because the user took their rules out
+ *   connected  every tool above
+ */
+export function rulesInstallPlan(status) {
+  const plan = { pending: [], inPlace: [], attention: [], skipped: [], connected: [] };
+  for (const host of RULES_INSTALL_HOSTS) {
+    const info = status?.hosts?.[host];
+    if (!info || info.detected === false) continue;
+    if (info.managed !== true && info.mcp !== true) continue;
+    plan.connected.push(host);
+    if (RULES_IN_PLACE.includes(info.state)) plan.inPlace.push(host);
+    else if (info.managed === false || info.partialRemoval) plan.skipped.push(host);
+    else if (info.state === 'not-installed' || info.state === 'outdated') plan.pending.push(host);
+    else plan.attention.push(host);
+  }
+  return plan;
+}
+
+/**
+ * The same report for rules that are in place already: the wizard reaches its rules step after its own toggles
+ * installed them, and says what Settings says after "install for all". Null when no connected tool has rules.
+ */
+export function describeRulesInPlace(status, { tx, labels = RULES_HOST_LABELS }) {
+  const results = {};
+  for (const host of rulesInstallPlan(status).inPlace) results[host] = { ok: true, changed: true, path: status.hosts[host].path };
+  return Object.keys(results).length ? describeRulesInstallAll({ results }, { tx, labels }) : null;
+}
+
+/**
+ * `tx` over a loaded catalogue (the parsed i18n/en.json), for a page that does not run the app's i18n: the
+ * onboarding wizard is English only and must not wait for the app's storage. Same rules as t() in i18n.js:
+ * a missing key comes back as the key, `{name}` is filled from `params`.
+ */
+export function catalogueTranslator(messages) {
+  return (key, params) => {
+    const value = String(key).split('.').reduce((node, part) => node?.[part], messages);
+    if (typeof value !== 'string') return key;
+    return params ? value.replace(/\{(\w+)\}/g, (_, name) => (params[name] != null ? params[name] : `{${name}}`)) : value;
+  };
+}

package/neural-interface/public/shared/settings/settings-user-context.js

@@ -0,0 +1,154 @@
+// ═══════════════════════════════════════════
+// SETTINGS — the Assistant's user context, in words
+// ═══════════════════════════════════════════
+//
+// What `GET /api/assistant/user-context` (lib/assistant-api.js, the engine in lib/assistant-user-context.js)
+// says about Settings → Automations → Automation behavior: whether the three switches can be used at all,
+// what each one is set to, what stands in the way of a layer, and whether the digest is in use. Pure: no DOM
+// and no import, so node runs it (tests/settings-user-context-view.test.mjs).
+//
+//   readUserContextResponse({ status, body, error })   what the server answered → a reading
+//   describeUserContext(reading, { tx })                the section as ui-settings.js draws it
+//   describeUserContextSaveFailure(input, { tx })       the sentence for a switch that could not be saved
+//
+// `tx(key, params)` is the caller's translate function over the settings.redesign.* strings (the kit's `tx`).
+//
+// The section never shows a healthy-looking control for something that is not happening: a server without
+// the engine gets disabled rows and says why, a switched-off layer says what stops, and the digest is shown
+// as told to a new conversation only while "Knowledge of you" is on (the engine's preview is built either way).
+
+const K = 'settings.redesign.hooks.uc';
+
+/** The three layers, in the order the section lists them. */
+export const USER_CONTEXT_LAYERS = Object.freeze(['knowledge', 'nudges', 'trace']);
+
+const clean = (value, max = 200) => {
+  const text = String(value ?? '').replace(/\s+/g, ' ').trim();
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+};
+
+/**
+ * What the server answered.
+ *
+ *   ready        the engine is there: `payload` is { settings, capabilities, preview }
+ *   old-server   404: the running server was started before the engine existed (public/ reloads at any
+ *                time, lib/ only on a restart)
+ *   failed       503 USER_CONTEXT_UNAVAILABLE: the engine did not start at boot; `reason` is the error
+ *   unreadable   anything else (no answer, a refusal, a body that is not the payload); `reason` says what
+ *
+ * @param {{ status?: number, body?: object|null, error?: string|null }} response
+ * @returns {{ state: 'ready'|'old-server'|'failed'|'unreadable', payload: object|null, reason: string|null }}
+ */
+export function readUserContextResponse({ status = 0, body = null, error = null } = {}) {
+  if (status === 200 && body?.ok === true && body.settings && typeof body.settings === 'object') return { state: 'ready', payload: body, reason: null };
+  if (status === 404) return { state: 'old-server', payload: null, reason: null };
+  if (status === 503 && body?.code === 'USER_CONTEXT_UNAVAILABLE') return { state: 'failed', payload: null, reason: clean(body.reason) || null };
+  return { state: 'unreadable', payload: null, reason: clean(body?.error || error) || (status ? `HTTP ${status}` : null) };
+}
+
+/** The settings as booleans, the way the engine reads them: anything that is not exactly `false` is on. */
+const layersOf = (settings) => Object.fromEntries(USER_CONTEXT_LAYERS.map((key) => [key, settings?.[key] !== false]));
+
+// Why learning cannot run → the sentence, and whether Settings → AI decisions is where to fix it.
+const LEARNING_REASONS = {
+  'kill-switch': { key: 'learn.killSwitch', link: false },
+  'master-off': { key: 'learn.masterOff', link: 'jv-sec-master' },
+  'no-key': { key: 'learn.noKey', link: 'jv-sec-connection' },
+  'surface-off': { key: 'learn.surfaceOff', link: 'jv-sec-surfaces' },
+  waiting: { key: 'learn.waiting', link: false },
+};
+
+/**
+ * The section as it is drawn.
+ *
+ * `note`: one line above the switches when they cannot be used (and why), else null.
+ * `layers[key]`: `on` (the stored value; false while it cannot be read), `disabled`, and `notes`: what stands
+ * in the way of that layer right now, each `{ text, tone: 'warn'|'info', link }` where `link` is
+ * `{ label, target }` (a Settings deep link) or null.
+ * `applies`: the line that says when a change takes effect, or ''.
+ * `digest`: `shown` (false without the engine), `state` 'in-use' | 'empty' | 'off', the `count` text, the `rows`
+ * to list (none while off), the `message` shown in place of rows (or ''), and the `omitted` line (or '').
+ *
+ * @param {{ state: string, payload: object|null, reason: string|null }} reading
+ * @param {{ tx: (key: string, params?: object) => string }} deps
+ */
+export function describeUserContext(reading, { tx }) {
+  const state = reading?.state || 'unreadable';
+  const ready = state === 'ready';
+  const page = tx('settings.redesign.page.ai_decisions.title');
+  const view = {
+    state, ready, note: null, applies: ready ? tx(`${K}.applies`) : '',
+    layers: Object.fromEntries(USER_CONTEXT_LAYERS.map((key) => [key, { on: false, disabled: !ready, notes: [] }])),
+    digest: { shown: false, state: 'off', count: '', rows: [], message: '', omitted: '' },
+  };
+
+  if (!ready) {
+    const reason = clean(reading?.reason);
+    if (state === 'old-server') view.note = { text: tx(`${K}.restart`), tone: 'warn' };
+    else if (state === 'failed') view.note = { text: reason ? tx(`${K}.failed`, { reason }) : tx(`${K}.failedNoReason`), tone: 'warn' };
+    else view.note = { text: reason ? tx(`${K}.unreadable`, { reason }) : tx(`${K}.unreadableNoReason`), tone: 'warn' };
+    return view;
+  }
+
+  const { settings, capabilities, preview } = reading.payload;
+  const on = layersOf(settings);
+  const caps = capabilities && typeof capabilities === 'object' ? capabilities : {};
+  for (const key of USER_CONTEXT_LAYERS) view.layers[key].on = on[key];
+
+  // Without the memory store nothing is read, learned or recorded: both layers that live in it say so.
+  const noStore = caps.store === false;
+  if (noStore) {
+    if (on.knowledge) view.layers.knowledge.notes.push({ text: tx(`${K}.noStore`), tone: 'warn', link: null });
+    if (on.nudges) view.layers.nudges.notes.push({ text: tx(`${K}.noStore`), tone: 'warn', link: null });
+  }
+  // Learning needs Jev on the `user-learning` surface; the digest does not.
+  if (on.knowledge && !noStore && caps.jev === false) {
+    const known = LEARNING_REASONS[caps.jevReason] || { key: 'learn.unavailable', link: false };
+    view.layers.knowledge.notes.push({
+      text: tx(`${K}.${known.key}`, { page }), tone: 'warn',
+      link: known.link ? { label: tx(`${K}.openPage`, { page }), target: { tab: 'ai-decisions', scrollTo: known.link } } : null,
+    });
+  }
+  // The statement writer: without it (or when its last one-shot failed) a statement stays in the user's own words.
+  if (on.knowledge && !noStore && caps.jev !== false) {
+    if (caps.writer === false) view.layers.knowledge.notes.push({ text: tx(`${K}.writer.missing`), tone: 'info', link: null });
+    else if (caps.writerLast && caps.writerLast.ok === false) {
+      const reason = clean(caps.writerLast.reason, 120);
+      view.layers.knowledge.notes.push({ text: reason ? tx(`${K}.writer.failed`, { reason }) : tx(`${K}.writer.failedNoReason`), tone: 'info', link: null });
+    }
+  }
+  // The trace is a line about the two layers: with both off the engine emits nothing.
+  if (on.trace && !on.knowledge && !on.nudges) view.layers.trace.notes.push({ text: tx(`${K}.trace.nothing`), tone: 'info', link: null });
+
+  // The digest: what a new conversation is told, which is nothing while the layer is off.
+  const rows = Array.isArray(preview?.rows) ? preview.rows.filter((row) => row && row.id && row.statement) : [];
+  const omitted = Number(preview?.omitted) > 0 ? Math.round(Number(preview.omitted)) : 0;
+  view.digest.shown = true;
+  if (!on.knowledge) {
+    view.digest.state = 'off';
+    view.digest.count = tx('settings.redesign.common.off');
+    view.digest.message = tx(`${K}.off.note`);
+  } else {
+    view.digest.state = rows.length ? 'in-use' : 'empty';
+    view.digest.count = tx(`${K}.tokens`, { tokens: Math.max(0, Math.round(Number(preview?.tokens) || 0)), max: Math.round(Number(preview?.maxTokens) || 300) });
+    view.digest.rows = rows.map((row) => ({ id: String(row.id), statement: String(row.statement), facet: String(row.facet || ''), seed: row.seed === true }));
+    view.digest.message = rows.length ? '' : tx(`${K}.empty`);
+    view.digest.omitted = omitted > 0 ? tx(`${K}.omitted`, { n: omitted }) : '';
+  }
+  return view;
+}
+
+/**
+ * A switch that could not be saved: it goes back to where it was, and this is the sentence that says so.
+ *
+ * @param {{ name: string, wanted: boolean, status?: number, body?: object|null, error?: string|null }} input
+ *        `name` is the switch's label, `wanted` what the click asked for
+ * @returns {string}
+ */
+export function describeUserContextSaveFailure({ name, wanted, status = 0, body = null, error = null } = {}, { tx }) {
+  let reason = clean(body?.error || body?.message, 160);
+  if (!reason && status === 404) reason = tx(`${K}.save.oldServer`);
+  if (!reason && status) reason = `HTTP ${status}`;
+  if (!reason) reason = clean(error, 160) || tx(`${K}.save.noAnswer`);
+  return tx(`${K}.save.${wanted ? 'on' : 'off'}`, { name, reason });
+}