apple-notes-tui 1.0.0

package/src/config.js

@@ -0,0 +1,27 @@
+// User config lives at ~/.config/notes-cli/config.json (or $XDG_CONFIG_HOME).
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const configDir = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+export const configPath = path.join(configDir, 'notes-cli', 'config.json');
+
+export const DEFAULTS = {
+  keymap: 'hybrid', // hybrid | vim | emacs
+  sort: 'modified', // modified | created | title
+  keys: {}, // extra bindings per action, e.g. { "quit": ["x"] }
+};
+
+export function loadConfig() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    return { ...DEFAULTS, ...raw, keys: raw.keys || {} };
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+
+export function saveConfig(cfg) {
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(cfg, null, 2) + '\n');
+}

package/src/keys.js

@@ -0,0 +1,172 @@
+// Raw stdin parsing and keymap resolution (hybrid / vim / emacs + user overrides).
+
+// Turns a raw stdin string into a list of key names like:
+// 'a', 'G', 'ctrl+d', 'meta+v', 'up', 'pagedown', 'enter', 'escape', 'space'.
+// Mouse input (SGR mode) yields 'wheelup'/'wheeldown' for the scroll wheel
+// and a { x, y } object (1-based screen cells) for a left-button press.
+export function parseInput(str) {
+  const keys = [];
+  let i = 0;
+  while (i < str.length) {
+    const ch = str[i];
+    if (ch === '\x1b') {
+      const next = str[i + 1];
+      if (next === '[' || next === 'O') {
+        let j = i + 2;
+        let seq = '';
+        while (j < str.length && !/[A-Za-z~]/.test(str[j])) {
+          seq += str[j];
+          j++;
+        }
+        const full = seq + (str[j] || '');
+        const map = {
+          A: 'up', B: 'down', C: 'right', D: 'left',
+          H: 'home', F: 'end', Z: 'shift+tab',
+          '1~': 'home', '3~': 'delete', '4~': 'end',
+          '5~': 'pageup', '6~': 'pagedown',
+        };
+        if (full[0] === '<' && /[Mm]$/.test(full)) {
+          // SGR mouse report: \x1b[<button;x;y then M (press) or m (release)
+          const [b, x, y] = full.slice(1, -1).split(';').map(Number);
+          if (full.endsWith('M')) {
+            if (b === 64) keys.push('wheelup');
+            else if (b === 65) keys.push('wheeldown');
+            else if (b === 0) keys.push({ x, y });
+          }
+        } else if (map[full]) keys.push(map[full]);
+        i = j + 1;
+      } else if (next !== undefined) {
+        keys.push('meta+' + next);
+        i += 2;
+      } else {
+        keys.push('escape');
+        i += 1;
+      }
+    } else if (ch === '\r' || ch === '\n') {
+      keys.push('enter');
+      i++;
+    } else if (ch === '\t') {
+      keys.push('tab');
+      i++;
+    } else if (ch === '\x7f' || ch === '\b') {
+      keys.push('backspace');
+      i++;
+    } else if (ch === ' ') {
+      keys.push('space');
+      i++;
+    } else {
+      const code = ch.charCodeAt(0);
+      if (code < 32) {
+        keys.push('ctrl+' + String.fromCharCode(code + 96));
+        i++;
+      } else {
+        const c = String.fromCodePoint(str.codePointAt(i));
+        keys.push(c);
+        i += c.length;
+      }
+    }
+  }
+  return keys;
+}
+
+// Bindings active in every keymap. Arrow keys always work.
+const COMMON = {
+  up: ['up'],
+  down: ['down'],
+  pageUp: ['pageup'],
+  pageDown: ['pagedown', 'space'],
+  top: ['home'],
+  bottom: ['end'],
+  open: ['enter'],
+  back: ['escape'],
+  prev: ['left'],
+  next: ['right'],
+  openExternal: ['o'],
+  openFile: ['a'],
+  edit: ['e'],
+  new: ['n'],
+  quit: ['q', 'ctrl+c'],
+  help: ['?'],
+  refresh: ['r'],
+  search: ['/'],
+  settings: ['s'],
+};
+
+const VIM = {
+  down: ['j'],
+  up: ['k'],
+  pageDown: ['ctrl+d', 'ctrl+f'],
+  pageUp: ['ctrl+u', 'ctrl+b'],
+  top: ['g g'], // chord: g then g
+  bottom: ['G'],
+  prev: ['h'],
+  next: ['l'],
+};
+
+const EMACS = {
+  down: ['ctrl+n'],
+  up: ['ctrl+p'],
+  pageDown: ['ctrl+v'],
+  pageUp: ['meta+v'],
+  top: ['meta+<'],
+  bottom: ['meta+>'],
+  back: ['ctrl+g'],
+};
+
+// Merges COMMON + preset(s) + user overrides into { action: [keys...] }.
+export function effectiveBindings(config) {
+  const sets = [COMMON];
+  if (config.keymap === 'vim' || config.keymap === 'hybrid') sets.push(VIM);
+  if (config.keymap === 'emacs' || config.keymap === 'hybrid') sets.push(EMACS);
+  const map = {};
+  for (const set of sets) {
+    for (const [action, keys] of Object.entries(set)) {
+      map[action] = [...(map[action] || []), ...keys];
+    }
+  }
+  for (const [action, keys] of Object.entries(config.keys || {})) {
+    const extra = Array.isArray(keys) ? keys : [keys];
+    map[action] = [...extra, ...(map[action] || [])];
+  }
+  return map;
+}
+
+// Resolves a key press to an action, tracking two-key chords like 'g g'.
+// Returns { action, pending } — pending is the chord prefix awaiting its
+// second key, if any.
+export function actionFor(bindings, key, pending) {
+  if (pending) {
+    const combo = pending + ' ' + key;
+    for (const [action, keys] of Object.entries(bindings)) {
+      if (keys.includes(combo)) return { action, pending: null };
+    }
+  }
+  for (const keys of Object.values(bindings)) {
+    for (const k of keys) {
+      if (k.startsWith(key + ' ')) return { action: null, pending: key };
+    }
+  }
+  for (const [action, keys] of Object.entries(bindings)) {
+    if (keys.includes(key)) return { action, pending: null };
+  }
+  return { action: null, pending: null };
+}
+
+const KEY_LABELS = {
+  up: '↑', down: '↓', left: '←', right: '→',
+  enter: '↵', escape: 'esc', space: 'space',
+  pageup: 'PgUp', pagedown: 'PgDn', home: 'Home', end: 'End',
+  backspace: '⌫',
+};
+
+export function prettyKey(key) {
+  return key
+    .split(' ')
+    .map((part) => {
+      if (KEY_LABELS[part]) return KEY_LABELS[part];
+      if (part.startsWith('ctrl+')) return 'Ctrl-' + part.slice(5);
+      if (part.startsWith('meta+')) return 'Alt-' + part.slice(5);
+      return part;
+    })
+    .join(' ');
+}

package/src/store.js

@@ -0,0 +1,174 @@
+// Data layer: talks to Notes.app over Apple Events via osascript (JXA).
+// Kept behind this interface so a faster backend (e.g. direct SQLite reads)
+// could be swapped in later without touching the UI.
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+function runJXA(script) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      'osascript',
+      ['-l', 'JavaScript', '-e', script],
+      { maxBuffer: 64 * 1024 * 1024, timeout: 60_000 },
+      (err, stdout, stderr) => {
+        if (err) {
+          const msg = (stderr || err.message || '').trim();
+          if (/-1743|not authori[sz]ed/i.test(msg)) {
+            reject(new Error(
+              'macOS blocked access to Notes.\n' +
+              'Open System Settings → Privacy & Security → Automation and\n' +
+              'allow your terminal app to control Notes, then try again.'
+            ));
+          } else {
+            reject(new Error(msg || 'osascript failed'));
+          }
+          return;
+        }
+        resolve(stdout.trim());
+      }
+    );
+  });
+}
+
+const LIST_SCRIPT = `
+(() => {
+  const app = Application('Notes');
+  const out = [];
+  for (const folder of app.folders()) {
+    const folderName = folder.name();
+    if (folderName === 'Recently Deleted') continue;
+    let ids, titles, modified, created;
+    try {
+      const notes = folder.notes;
+      ids = notes.id();
+      titles = notes.name();
+      modified = notes.modificationDate();
+      created = notes.creationDate();
+    } catch (e) {
+      continue;
+    }
+    let locked = null;
+    try { locked = folder.notes.passwordProtected(); } catch (e) {}
+    for (let i = 0; i < ids.length; i++) {
+      out.push({
+        id: ids[i],
+        title: titles[i] || 'Untitled',
+        folder: folderName,
+        modified: modified[i] ? modified[i].toISOString() : null,
+        created: created[i] ? created[i].toISOString() : null,
+        locked: locked ? !!locked[i] : false,
+      });
+    }
+  }
+  return JSON.stringify(out);
+})()`;
+
+export async function fetchNoteList() {
+  const raw = await runJXA(LIST_SCRIPT);
+  const notes = JSON.parse(raw);
+  const seen = new Set();
+  return notes.filter((n) => {
+    if (seen.has(n.id)) return false;
+    seen.add(n.id);
+    return true;
+  });
+}
+
+export async function fetchNoteText(id) {
+  const script = `
+(() => {
+  const app = Application('Notes');
+  const note = app.notes.byId(${JSON.stringify(id)});
+  let ids = [], names = [];
+  try {
+    ids = note.attachments.id();
+    names = note.attachments.name();
+  } catch (e) {}
+  return JSON.stringify({ text: note.plaintext(), ids, names });
+})()`;
+  const { text, ids, names } = JSON.parse(await runJXA(script));
+  const attachments = ids.map((attId, i) => ({ id: attId, name: names[i] || 'attachment' }));
+  // U+FFFC marks inline attachments (images, tables) that plaintext can't
+  // carry. They appear in the same order as the note's attachment list, so
+  // substitute each marker with the matching filename.
+  let i = 0;
+  const rendered = (text || '').replace(//g, () => {
+    const name = attachments[i++]?.name;
+    return name ? `[📎 ${name}]` : '[attachment]';
+  });
+  return { text: rendered, attachments };
+}
+
+// Exports an attachment through Notes.app (which can read its own container —
+// this process can't without Full Disk Access) and opens it with the default
+// app. Exports land in one temp dir per run and are reused on reopen.
+let exportDir = null;
+
+export async function openAttachment(noteId, attachment) {
+  if (!exportDir) exportDir = fs.mkdtempSync(path.join(os.tmpdir(), 'notes-cli-'));
+  const safe = (attachment.name || 'attachment').replace(/[/:]/g, '_');
+  const dest = path.join(exportDir, safe);
+  if (!fs.existsSync(dest)) {
+    const script = `
+(() => {
+  const app = Application('Notes');
+  const att = app.notes.byId(${JSON.stringify(noteId)}).attachments.byId(${JSON.stringify(attachment.id)});
+  app.save(att, { in: Path(${JSON.stringify(dest)}) });
+})()`;
+    await runJXA(script);
+  }
+  await new Promise((resolve, reject) => {
+    execFile('open', [dest], (err) => (err ? reject(err) : resolve()));
+  });
+}
+
+// Notes bodies are HTML: each line becomes a <div>, and Notes derives the
+// note title from the first line.
+function textToHtml(text) {
+  const esc = (s) =>
+    s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  return text
+    .split('\n')
+    .map((line) => (line.trim() ? `<div>${esc(line)}</div>` : '<div><br></div>'))
+    .join('');
+}
+
+// Replaces the note's body with plain text. Rich formatting and inline
+// attachments in the old body are lost, which the user accepted for
+// in-terminal editing.
+export async function saveNoteText(id, text) {
+  const html = textToHtml(text);
+  const script = `
+(() => {
+  const app = Application('Notes');
+  app.notes.byId(${JSON.stringify(id)}).body = ${JSON.stringify(html)};
+})()`;
+  await runJXA(script);
+}
+
+// Creates a note in the default account's default folder; returns its id.
+export async function createNote(text) {
+  const script = `
+(() => {
+  const app = Application('Notes');
+  const note = app.Note({ body: ${JSON.stringify(textToHtml(text))} });
+  app.defaultAccount.notes.push(note);
+  return note.id();
+})()`;
+  return runJXA(script);
+}
+
+// Brings the note up in Notes.app itself. For password-protected notes this
+// is the unlock path: Notes prompts for Touch ID / password, and once the
+// session is unlocked its text becomes readable over Apple Events too.
+export async function openInNotes(id) {
+  const script = `
+(() => {
+  const app = Application('Notes');
+  app.activate();
+  app.notes.byId(${JSON.stringify(id)}).show();
+})()`;
+  await runJXA(script);
+}

package/src/term.js

@@ -0,0 +1,103 @@
+// ANSI escape codes and text-measurement helpers for the TUI.
+
+export const altOn = '\x1b[?1049h\x1b[?25l'; // alt screen + hide cursor
+export const altOff = '\x1b[?1049l\x1b[?25h'; // restore screen + show cursor
+export const mouseOn = '\x1b[?1000h\x1b[?1006h'; // click + wheel reporting (SGR)
+export const mouseOff = '\x1b[?1006l\x1b[?1000l';
+export const home = '\x1b[H';
+export const clearBelow = '\x1b[0J';
+export const clearLine = '\x1b[K';
+
+export const bold = (s) => `\x1b[1m${s}\x1b[22m`;
+export const dim = (s) => `\x1b[2m${s}\x1b[22m`;
+
+const rgb = (r, g, b) => (s) => `\x1b[38;2;${r};${g};${b}m${s}\x1b[39m`;
+export const accent = rgb(215, 119, 87); // coral, à la Claude Code
+export const grey = rgb(150, 148, 145);
+
+// Approximate display width of a code point (wide CJK/emoji = 2, marks = 0).
+function charWidth(cp) {
+  if (cp === 0x200d || cp === 0xfe0f || (cp >= 0x300 && cp <= 0x36f)) return 0;
+  if (
+    (cp >= 0x1100 && cp <= 0x115f) ||
+    (cp >= 0x2e80 && cp <= 0xa4cf) ||
+    (cp >= 0xac00 && cp <= 0xd7a3) ||
+    (cp >= 0xf900 && cp <= 0xfaff) ||
+    (cp >= 0xfe30 && cp <= 0xfe4f) ||
+    (cp >= 0xff00 && cp <= 0xff60) ||
+    (cp >= 0xffe0 && cp <= 0xffe6) ||
+    (cp >= 0x1f000 && cp <= 0x1faff) ||
+    (cp >= 0x2600 && cp <= 0x27bf)
+  ) {
+    return 2;
+  }
+  return 1;
+}
+
+export function strWidth(s) {
+  let w = 0;
+  for (const ch of s) w += charWidth(ch.codePointAt(0));
+  return w;
+}
+
+export function truncate(s, width) {
+  if (width <= 0) return '';
+  if (strWidth(s) <= width) return s;
+  let out = '';
+  let w = 0;
+  for (const ch of s) {
+    const cw = charWidth(ch.codePointAt(0));
+    if (w + cw > width - 1) break;
+    out += ch;
+    w += cw;
+  }
+  return out + '…';
+}
+
+export function padEnd(s, width) {
+  const pad = width - strWidth(s);
+  return pad > 0 ? s + ' '.repeat(pad) : s;
+}
+
+// Truncates and pads plain text to an exact width, then optionally styles it.
+export function padRowPlain(s, width, styleFn) {
+  const text = padEnd(truncate(s, width), width);
+  return styleFn ? styleFn(text) : text;
+}
+
+// Word-wraps plain text to a given display width, hard-breaking long words.
+export function wrap(text, width) {
+  const out = [];
+  for (const rawLine of text.split('\n')) {
+    const line = rawLine.replace(/\t/g, '    ');
+    if (strWidth(line) <= width) {
+      out.push(line);
+      continue;
+    }
+    let cur = '';
+    for (const word of line.split(' ')) {
+      const candidate = cur ? cur + ' ' + word : word;
+      if (strWidth(candidate) <= width) {
+        cur = candidate;
+        continue;
+      }
+      if (cur) out.push(cur);
+      let rest = word;
+      while (strWidth(rest) > width) {
+        let piece = '';
+        let pw = 0;
+        for (const ch of rest) {
+          const cw = charWidth(ch.codePointAt(0));
+          if (pw + cw > width) break;
+          piece += ch;
+          pw += cw;
+        }
+        out.push(piece);
+        rest = rest.slice(piece.length);
+      }
+      cur = rest;
+    }
+    out.push(cur);
+  }
+  return out;
+}