sonorance 0.1.0-beta.4.1

package/src/ui/slash.mjs

@@ -0,0 +1,122 @@
+// Slash commands for the Tiptap surface — type "/" at the start of an empty
+// block to open a menu that inserts headings, lists, a task list, a table, a
+// code block, a quote, or a divider. Built on Tiptap's Suggestion utility with
+// a small self-rendered popup (no tippy dependency), so the block-insertion
+// affordance the hand-rolled editor never had comes for free with the WYSIWYG
+// surface.
+import { Extension } from '@tiptap/core';
+import { Suggestion } from '@tiptap/suggestion';
+import { PluginKey } from '@tiptap/pm/state';
+
+// The command palette. `run({ editor, range })` replaces the typed "/query"
+// (deleteRange) then applies the block transform.
+const COMMANDS = [
+  { title: 'Heading 1', keys: 'h1 heading title', run: ({ editor, range }) => editor.chain().focus().deleteRange(range).setNode('heading', { level: 1 }).run() },
+  { title: 'Heading 2', keys: 'h2 heading subtitle', run: ({ editor, range }) => editor.chain().focus().deleteRange(range).setNode('heading', { level: 2 }).run() },
+  { title: 'Heading 3', keys: 'h3 heading', run: ({ editor, range }) => editor.chain().focus().deleteRange(range).setNode('heading', { level: 3 }).run() },
+  { title: 'Bullet list', keys: 'ul bullet unordered list', run: ({ editor, range }) => editor.chain().focus().deleteRange(range).toggleBulletList().run() },
+  { title: 'Numbered list', keys: 'ol ordered numbered list', run: ({ editor, range }) => editor.chain().focus().deleteRange(range).toggleOrderedList().run() },
+  { title: 'Task list', keys: 'todo task checkbox check', run: ({ editor, range }) => editor.chain().focus().deleteRange(range).toggleTaskList().run() },
+  { title: 'Table', keys: 'table grid', run: ({ editor, range }) => editor.chain().focus().deleteRange(range).insertTable({ rows: 3, cols: 3, withHeaderRow: true }).run() },
+  { title: 'Code block', keys: 'code pre snippet', run: ({ editor, range }) => editor.chain().focus().deleteRange(range).setCodeBlock().run() },
+  { title: 'Quote', keys: 'quote blockquote', run: ({ editor, range }) => editor.chain().focus().deleteRange(range).toggleBlockquote().run() },
+  { title: 'Divider', keys: 'hr rule divider separator', run: ({ editor, range }) => editor.chain().focus().deleteRange(range).setHorizontalRule().run() },
+];
+
+function filter(query) {
+  const q = (query || '').toLowerCase().trim();
+  if (!q) return COMMANDS.slice(0, 10);
+  return COMMANDS.filter(c => (c.title + ' ' + c.keys).toLowerCase().includes(q)).slice(0, 10);
+}
+
+// The self-rendered popup — a plain list positioned at the caret. Returns the
+// Suggestion render hooks. Kept dependency-free (no floating-ui/tippy) so it
+// adds nothing to the bundle beyond the Suggestion utility itself. Shared with
+// the "@" mention (at-mention.mjs) so both palettes look and behave identically.
+export function makeRenderer() {
+  let el = null, items = [], active = 0, cmd = null;
+
+  const paint = () => {
+    if (!el) return;
+    el.innerHTML = '';
+    if (!items.length) { el.classList.remove('show'); return; }
+    el.classList.add('show');
+    items.forEach((it, i) => {
+      const b = document.createElement('button');
+      b.type = 'button';
+      b.className = 'slashitem' + (i === active ? ' active' : '');
+      b.textContent = it.title;
+      b.addEventListener('mousedown', (e) => { e.preventDefault(); pick(i); });
+      el.appendChild(b);
+    });
+  };
+
+  const place = (props) => {
+    if (!el) return;
+    let rect = null;
+    try { rect = props.clientRect && props.clientRect(); } catch { rect = null; }
+    const vw = window.innerWidth || 1200, vh = window.innerHeight || 800;
+    const w = el.offsetWidth || 220, h = el.offsetHeight || 240;
+    const left = rect ? Math.min(rect.left, vw - w - 8) : 40;
+    const top = rect ? Math.min(rect.bottom + 6, vh - h - 8) : 80;
+    el.style.left = Math.max(8, left) + 'px';
+    el.style.top = Math.max(8, top) + 'px';
+  };
+
+  const pick = (i) => {
+    const it = items[i]; if (!it || !cmd) return;
+    cmd(it);
+  };
+
+  return {
+    onStart(props) {
+      cmd = props.command; items = props.items; active = 0;
+      el = document.createElement('div');
+      el.className = 'slashmenu';
+      el.setAttribute('role', 'listbox');
+      document.body.appendChild(el);
+      paint(); place(props);
+    },
+    onUpdate(props) {
+      cmd = props.command; items = props.items; if (active >= items.length) active = 0;
+      paint(); place(props);
+    },
+    onKeyDown(props) {
+      const k = props.event.key;
+      if (k === 'Escape') { destroy(); return true; }
+      if (!items.length) return false;
+      if (k === 'ArrowDown') { active = (active + 1) % items.length; paint(); return true; }
+      if (k === 'ArrowUp') { active = (active - 1 + items.length) % items.length; paint(); return true; }
+      if (k === 'Enter') { pick(active); return true; }
+      return false;
+    },
+    onExit() { destroy(); },
+  };
+
+  function destroy() { if (el) { el.remove(); el = null; } items = []; }
+}
+
+export const SlashCommands = Extension.create({
+  name: 'slashCommands',
+  addProseMirrorPlugins() {
+    return [
+      Suggestion({
+        editor: this.editor,
+        pluginKey: new PluginKey('slashSuggestion'),
+        char: '/',
+        startOfLine: false,
+        allowSpaces: false,
+        // Only trigger at the start of an empty-ish block, so "/" inside prose
+        // (e.g. and/or, a path) never pops the menu.
+        allow: ({ state, range }) => {
+          const $from = state.doc.resolve(range.from);
+          const before = $from.parent.textBetween(0, $from.parentOffset, undefined, ' ');
+          return /(^|\s)\/?$/.test(before) && $from.parent.type.name === 'paragraph';
+        },
+        items: ({ query }) => filter(query),
+        command: ({ editor, range, props }) => props.run({ editor, range }),
+        render: makeRenderer,
+      }),
+    ];
+  },
+});

package/src/vault-registry.mjs

@@ -0,0 +1,150 @@
+/**
+ * vault-registry.mjs — the Sonorance multi-vault registry.
+ *
+ * A **vault** is a plain folder that is its own source of truth; opening one marks it with a
+ * hidden `.sonorance/` platform dir whose single `config.json` holds everything per-vault:
+ * identity (id/name/created_at), the optional engine pointer (flavor), grounding sources, and
+ * workbench state (tabs/explorer). This module owns the ONE global list of known vaults and
+ * which is current, stored at `~/.sonorance/config.json` (override the home with
+ * `SONORANCE_HOME`, e.g. in tests).
+ *
+ * It is the platform's registry, not a product's: the standalone Sonorance editor uses it to
+ * open and switch between folders, and the `deliberate` host reuses it for its projects (a
+ * Deliberate vault is just a folder that also carries `deliberate/` content). Because it is a
+ * shared seam, both sides read/write the SAME `~/.sonorance/config.json`.
+ *
+ * Design:
+ *   • Vaults are keyed by ABSOLUTE PATH (dedup by path, not by a name-slug that can collide).
+ *   • Identity (id/name) is READ from each vault's `.sonorance/config.json`; a live folder that
+ *     lacks one is SELF-HEALED (the identity is written from the basename) rather than dropped —
+ *     so a registered folder never silently disappears from the switcher.
+ *   • A registered folder whose directory no longer exists is reported with `exists:false` (the
+ *     UI offers Remove); it is never hidden silently.
+ *   • Only the `vaults` + `current` keys are owned in the GLOBAL config; the per-vault config's
+ *     other keys (sources, tabs, engine, …) are preserved on write.
+ */
+import { homedir } from 'node:os';
+import { join, resolve, dirname, basename } from 'node:path';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from 'node:fs';
+
+// The single platform home. `SONORANCE_HOME` overrides it (tests point it at a temp dir so the
+// suite never touches the real `~/.sonorance`).
+export const sonoranceHome = () => process.env.SONORANCE_HOME || join(homedir(), '.sonorance');
+export const registryConfigPath = () => join(sonoranceHome(), 'config.json');
+
+const slug = (s) => String(s || '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 60) || 'project';
+const stateDir = (dir) => join(dir, '.sonorance');
+// A vault's single per-vault config file — identity + sources + engine + workbench state.
+export const vaultConfigPath = (dir) => join(stateDir(dir), 'config.json');
+
+const readConfig = () => { try { return JSON.parse(readFileSync(registryConfigPath(), 'utf8')); } catch { return {}; } };
+const writeConfig = (c) => {
+  const p = registryConfigPath();
+  mkdirSync(dirname(p), { recursive: true });
+  const tmp = `${p}.tmp-${process.pid}`;
+  writeFileSync(tmp, JSON.stringify(c, null, 2) + '\n');
+  renameSync(tmp, p);                                   // atomic: readers see the old or the new whole
+};
+
+// A vault's per-vault config (`.sonorance/config.json`) — the ONE file per vault. Read-modify-write
+// preserves keys other writers own (the engine's tabs/explorer, the host's sources/gate/engine).
+const readVaultConfig = (dir) => { try { return JSON.parse(readFileSync(vaultConfigPath(dir), 'utf8')); } catch { return {}; } };
+const writeVaultConfig = (dir, cfg) => {
+  const p = vaultConfigPath(dir);
+  mkdirSync(dirname(p), { recursive: true });
+  const tmp = `${p}.tmp-${process.pid}`;
+  writeFileSync(tmp, JSON.stringify(cfg, null, 2) + '\n');
+  renameSync(tmp, p);
+};
+
+// Read `id`/`name` from a vault's `.sonorance/config.json`. Absent → {}.
+function readMeta(dir) {
+  const c = readVaultConfig(dir);
+  return { id: c.id, name: c.name };
+}
+
+// Ensure the vault has identity in its config — this is what makes a folder a project. Called on
+// register and as SELF-HEAL when a live folder is missing it. Never overwrites an existing id;
+// merges into whatever else the config already holds (sources, tabs, engine, …).
+function ensureMarker(dir, name) {
+  const c = readVaultConfig(dir);
+  if (c.id) return;
+  const nm = name || basename(dir) || 'project';
+  c.id = slug(nm);
+  if (!c.name) c.name = nm;
+  if (c.created_at == null) c.created_at = Date.now();
+  writeVaultConfig(dir, c);
+}
+
+const identityOf = (dir) => {
+  const meta = existsSync(dir) ? readMeta(dir) : {};
+  return { id: meta.id || slug(basename(dir)), name: meta.name || basename(dir) || 'project', dir };
+};
+
+export function createRegistry() {
+  const vaultDirs = () => { const c = readConfig(); return Array.isArray(c.vaults) ? c.vaults : []; };
+
+  const reg = {
+    home: sonoranceHome,
+    configPath: registryConfigPath,
+
+    // Every known vault: { id, name, dir, exists }. A live folder missing its marker is healed
+    // (marker recreated from the basename) so it keeps a stable identity and never drops out.
+    list() {
+      return vaultDirs().map(dir => {
+        const exists = existsSync(dir);
+        if (exists) ensureMarker(dir);                  // self-heal a live folder that lost its marker
+        return { ...identityOf(dir), exists };
+      });
+    },
+    // Resolve a vault by absolute path OR by id. Null if not registered.
+    get(idOrDir) {
+      if (!idOrDir) return null;
+      const abs = resolve(String(idOrDir));
+      return this.list().find(v => v.dir === abs || v.id === idOrDir) || null;
+    },
+    // The current vault. Falls back to the first EXISTING vault so a fresh/stale pointer still
+    // resolves to something usable.
+    current() {
+      const c = readConfig();
+      const list = this.list();
+      return (c.current && list.find(v => v.dir === c.current)) || list.find(v => v.exists) || null;
+    },
+    setCurrent(idOrDir) {
+      const v = this.get(idOrDir); if (!v) return null;
+      const c = readConfig(); c.current = v.dir; writeConfig(c);
+      return v;
+    },
+    // Read-only id → dir resolution (no self-heal write) — for hot path resolvers that must
+    // stay cheap and side-effect-free (e.g. Deliberate's `vaultPath`). Null if unregistered.
+    dirById(id) {
+      if (!id) return null;
+      for (const dir of vaultDirs()) { if (identityOf(dir).id === id) return dir; }
+      return null;
+    },
+    // Register a folder as a vault (creating its `.sonorance/` marker) and, by default, make it
+    // current — the "open folder" / "open another vault" action. Idempotent per absolute path.
+    register(dir, { name, makeCurrent = true } = {}) {
+      const abs = resolve(dir);
+      ensureMarker(abs, name);
+      const c = readConfig();
+      c.vaults = Array.isArray(c.vaults) ? c.vaults : [];
+      if (!c.vaults.includes(abs)) c.vaults.push(abs);
+      if (makeCurrent || !c.current) c.current = abs;
+      writeConfig(c);
+      return this.get(abs);
+    },
+    // Drop a vault from the registry (the UI's Remove for a missing folder). Does NOT delete the
+    // folder or its `.sonorance/`; only forgets it. Re-points `current` if it was the removed one.
+    remove(idOrDir) {
+      const v = this.get(idOrDir);
+      const abs = v ? v.dir : resolve(String(idOrDir));
+      const c = readConfig();
+      c.vaults = (Array.isArray(c.vaults) ? c.vaults : []).filter(d => d !== abs);
+      if (c.current === abs) c.current = c.vaults[0] || null;
+      writeConfig(c);
+      return true;
+    },
+  };
+  return reg;
+}