bantamkit-mcp 0.35.7 → 0.35.9

package/dist/hostinstall.js

@@ -12,9 +12,10 @@
  *      never `JSON.stringify`. Python writes `{"args": [], "command": "OLD"}` and
  *      `JSON.stringify` writes `{"args":[],"command":"OLD"}` — same object, different
  *      bytes, and the separators are the whole difference.
- *   2. The file is written with the same helper at `indent: 2`, which also reproduces
- *      `ensure_ascii`. A home directory with a non-ASCII name would otherwise make the two
- *      runtimes write different bytes for the same install.
+ *   2. The file is written through `hostJsonText`, which reproduces the reference's
+ *      `json.dumps(data, indent=<the file's own unit>, ensure_ascii=False)` (#118): the user's
+ *      Thai text stays Thai, their 4-space or tab indent stays theirs, and the two runtimes
+ *      still write identical bytes — `install-host-text` in the install suite compares them.
  *
  * WHAT IS RULED DIFFERENT, and it is one field: the COMMAND. This side records
  * `<absolute node> <absolute .../dist/cli.js>`; the reference records its own console script.
@@ -32,14 +33,14 @@
  * launches it without the network. See `thisCommand`.
  */
 import { spawnSync } from 'node:child_process';
-import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { currentInstall, Undetermined } from './mcp/identity.js';
 import { bantamkitDirFor, ensureBantamkitGitignore } from './memory/store.js';
 import { compareVersions, keptCli, keptManifest, keptPrefix, PACKAGE, runInstaller, shlexJoin } from './npminstall.js';
-import { dumpJson, fromJs } from './pyjson.js';
+import { dumpJson, fromJs, parseJson, PyJSONDecodeError } from './pyjson.js';
 export { keptCli, keptPrefix };
 /** The four hosts, in the order they print in `--help`. */
 export const HOSTS = ['claude', 'claude-desktop', 'copilot', 'cursor'];
@@ -49,6 +50,7 @@ export const ENTRY = 'bantamkit';
 export class InstallError extends Error {
 }
 const dumps = (value, indent = null, sortKeys = false) => dumpJson(fromJs(value), { indent, sortKeys });
+const pyDict = (entries) => ({ t: 'dict', v: new Map(entries) });
 /**
  * The file `--install <host>` would write, on THIS platform.
  *
@@ -100,25 +102,64 @@ export function entryFor(host, command, args) {
  * `[1, 2, 3]`, the ONE input where the two vocabularies happen to agree, so neither suite
  * could see it. Review measured `"hello"` and `5`.
  *
- * `int` vs `float` follows `json`'s own split: a JSON number with no fraction and no exponent
- * is decoded by `int`, everything else by `float`.
+ * Since #118 the value is tagged by the same split `json` makes — a JSON number with no
+ * fraction and no exponent is `int`, everything else `float` — so the tag IS the name.
  */
 function pyTypeName(value) {
-    if (value === null)
-        return 'NoneType';
-    if (Array.isArray(value))
-        return 'list';
-    if (typeof value === 'string')
-        return 'str';
-    if (typeof value === 'boolean')
-        return 'bool';
-    if (typeof value === 'number')
-        return Number.isInteger(value) ? 'int' : 'float';
-    return typeof value;
+    switch (value.t) {
+        case 'null':
+            return 'NoneType';
+        case 'bool':
+            return 'bool';
+        case 'int':
+            return 'int';
+        case 'float':
+            return 'float';
+        case 'str':
+            return 'str';
+        case 'list':
+            return 'list';
+        case 'dict':
+            return 'dict';
+    }
+}
+/**
+ * The first non-finite float in `value`, with where it sits, or `null`. Depth-first, in
+ * document order, so both runtimes name the same number when a file holds two.
+ */
+function nonFiniteIn(value, trail) {
+    if (value.t === 'float' && !Number.isFinite(value.v))
+        return { where: whereIs(trail), value: value.v };
+    if (value.t === 'dict') {
+        for (const [key, item] of value.v) {
+            const found = nonFiniteIn(item, [...trail, key]);
+            if (found !== null)
+                return found;
+        }
+    }
+    else if (value.t === 'list') {
+        for (const [index, item] of value.v.entries()) {
+            const found = nonFiniteIn(item, [...trail, index]);
+            if (found !== null)
+                return found;
+        }
+    }
+    return null;
+}
+/** `mcpServers.other.huge`, `servers.list[2]`: keys joined by `.`, indexes in brackets. */
+function whereIs(trail) {
+    let out = '';
+    for (const segment of trail) {
+        if (typeof segment === 'number')
+            out += `[${segment}]`;
+        else
+            out += out === '' ? segment : `.${segment}`;
+    }
+    return out === '' ? 'the top level' : out;
 }
 function readConfig(path) {
     if (!existsSync(path))
-        return {};
+        return pyDict();
     let text;
     try {
         text = readFileSync(path, 'utf8');
@@ -127,51 +168,202 @@ function readConfig(path) {
         throw new InstallError(`cannot read ${path}: ${e.message}`);
     }
     if (text.trim() === '')
-        return {};
+        return pyDict();
     let loaded;
     try {
-        loaded = JSON.parse(text);
+        loaded = parseJson(text);
     }
     catch (e) {
-        // The reference reports CPython's message, line and column. `JSON.parse` gives neither
-        // the same wording nor a position, so this is a RULED difference rather than a silent
-        // one: both refuse, both name the file, and the reason after the colon differs.
-        throw new InstallError(`${path} is not valid JSON, so this refuses to touch it: ${e.message}`);
+        if (!(e instanceof PyJSONDecodeError))
+            throw e;
+        // The reference reports CPython's message, line and column, and so does this parser —
+        // the ruling that once covered V8's `Unexpected token …` wording retired with #118.
+        throw new InstallError(`${path} is not valid JSON, so this refuses to touch it: ${e.msg} (line ${e.lineno}, column ${e.colno})`);
     }
-    if (loaded === null || typeof loaded !== 'object' || Array.isArray(loaded)) {
+    if (loaded.t !== 'dict') {
         throw new InstallError(`${path} holds ${pyTypeName(loaded)}, not an object; refusing to touch it`);
     }
+    // A NUMBER JSON CANNOT CARRY IS REFUSED HERE, before anything is planned (#118). `1e400`
+    // decodes to `Infinity` and `dumpJson` — faithful to `json.dumps` — would write it back as
+    // that bare word, which no JSON parser accepts: the host then cannot read ANY of its
+    // servers, and the next run of this very command refuses its own output. The literals
+    // `NaN`/`Infinity` that CPython's decoder tolerates take the same door.
+    const found = nonFiniteIn(loaded, []);
+    if (found !== null) {
+        const spelled = dumpJson({ t: 'float', v: found.value });
+        throw new InstallError(`${path} has a number at ${found.where} that JSON cannot carry (${spelled}); refusing to touch it`);
+    }
     return loaded;
 }
+/**
+ * Where the bytes land: the file ITSELF, through any symlink (#136).
+ *
+ * A dotfiles user keeps `~/.cursor/mcp.json` as a link into a repository. Writing a temp file
+ * beside the LINK and renaming it onto the link's name replaces the link with a detached
+ * regular file: the repository copy never gets the entry and the next sync reverts it without
+ * a word. `realpathSync` wants the target to exist; a link whose target is not there yet is
+ * followed by hand (the reference's `os.path.realpath` is non-strict), so the write creates
+ * the target and the link stays a link either way.
+ */
+function writeTarget(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        // ENOENT: a fresh file, or a link whose target does not exist yet.
+    }
+    let at = path;
+    for (let hops = 0; hops < 40; hops += 1) {
+        let link;
+        try {
+            if (!lstatSync(at).isSymbolicLink())
+                return at;
+            link = readlinkSync(at);
+        }
+        catch {
+            return at;
+        }
+        at = resolve(dirname(at), link);
+    }
+    return at;
+}
+/**
+ * Write the whole document, atomically, leaving no half-file behind on a crash — and atomic
+ * ONTO THE REAL FILE: the temp file is made beside `writeTarget(path)` and renamed onto it, so
+ * a symlinked config is written through rather than swapped for a regular file.
+ */
 function writeConfig(path, data) {
     mkdirSync(dirname(path), { recursive: true });
-    const tmp = `${path}.bantamkit-tmp`;
+    const target = writeTarget(path);
+    if (target !== path)
+        mkdirSync(dirname(target), { recursive: true });
+    const tmp = `${target}.bantamkit-tmp`;
     // The mode of the file being replaced, carried onto its replacement. A host config holds
     // API keys in per-server `env` blocks, and a user who chmod'ed theirs to 0600 had it come
     // back 0644, because a fresh temp file gets the process umask. Measured on both runtimes
     // before this line existed.
-    const mode = existsSync(path) ? statSync(path).mode & 0o7777 : null;
+    const mode = existsSync(target) ? statSync(target).mode & 0o7777 : null;
     try {
-        writeFileSync(tmp, `${dumps(data, 2)}\n`, 'utf8');
+        writeFileSync(tmp, `${hostJsonText(data, detectedIndent(target))}\n`, 'utf8');
         if (mode !== null)
             chmodSync(tmp, mode);
-        renameSync(tmp, path);
+        renameSync(tmp, target);
     }
     catch (e) {
         rmSync(tmp, { force: true });
         throw new InstallError(`cannot write ${path}: ${e.message}`);
     }
 }
+/**
+ * The indent unit the file already uses: a tab, or N spaces; two for a new file (#118).
+ *
+ * Read off the FIRST line that starts with whitespace and has something after it. A JSON
+ * string cannot hold a raw newline, so every line start is structural and that line is a
+ * depth-one member. A file with no such line (absent, empty, all on one line) gets two
+ * spaces, which is what this writer always used. The reference's `_detected_indent` applies
+ * the same rule to the same text.
+ *
+ * Lines break where Python's universal newlines break them — `\r\n`, a bare `\r`, or `\n` —
+ * because the reference reads through `Path.read_text`, which translates all three. Splitting
+ * on `\n` alone saw a classic-Mac (CR-only) file as one line, fell back to two spaces, and so
+ * wrote different bytes from the reference and lost the file's indent (#118, review J66-12 B1).
+ */
+function detectedIndent(path) {
+    let text;
+    try {
+        text = readFileSync(path, 'utf8');
+    }
+    catch {
+        return '  ';
+    }
+    for (const line of text.split(/\r\n|\r|\n/)) {
+        if ((line[0] !== ' ' && line[0] !== '\t') || !/[^ \t\r]/.test(line))
+            continue;
+        if (line[0] === '\t')
+            return '\t';
+        return ' '.repeat(line.length - line.replace(/^ +/, '').length);
+    }
+    return '  ';
+}
+/**
+ * The host file's text: the user's indent unit, non-ASCII as literal UTF-8 (#118) — the
+ * bytes the reference's `json.dumps(data, indent=<unit>, ensure_ascii=False)` writes.
+ *
+ * Built from `dumpJson`'s `ensure_ascii` output at indent 2, which is already CPython's in
+ * every other respect, by two rewrites that cannot touch a string's meaning:
+ *   - indentation: every line start in that output is structural (a string holds no raw
+ *     newline), and its leading spaces are exactly 2 × depth, so they become unit × depth;
+ *   - escapes: each `\uXXXX` at 0x7f or above goes back to the character itself — a valid
+ *     surrogate PAIR as one astral character — which is what `ensure_ascii=False` writes
+ *     (it escapes only `"`, `\` and C0). A LONE surrogate stays escaped: UTF-8 cannot carry
+ *     it, and the reference writes it back the same way. A `\\` pair is consumed first, so
+ *     the text `ก` inside a string (an escaped backslash) is never mistaken for one.
+ */
+function hostJsonText(data, indent) {
+    const ascii = dumpJson(data, { indent: 2 });
+    const unescaped = ascii.replace(/\\u(d[89ab][0-9a-f]{2})\\u(d[c-f][0-9a-f]{2})|\\u([0-9a-f]{4})|\\[^u]/g, (whole, high, low, single) => {
+        if (high !== undefined && low !== undefined) {
+            return String.fromCharCode(parseInt(high, 16), parseInt(low, 16));
+        }
+        if (single === undefined)
+            return whole;
+        const unit = parseInt(single, 16);
+        if (unit < 0x7f || (unit >= 0xd800 && unit <= 0xdfff))
+            return whole;
+        return String.fromCharCode(unit);
+    });
+    if (indent === '  ')
+        return unescaped;
+    return unescaped.replace(/^((?: {2})+)/gm, (lead) => indent.repeat(lead.length / 2));
+}
 /** `date.today().isoformat()` — the LOCAL date, which is what the reference takes. */
 function today() {
     const now = new Date();
     const pad = (n) => String(n).padStart(2, '0');
     return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
 }
+/** `os.path.lexists`: there is SOMETHING at this name, a dangling link included. */
+function lexists(path) {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The name the next backup of `path` gets: the first one that is not taken.
+ *
+ * `<name>.backup-<date>` when nothing holds that name, then `<name>.backup-<date>.1`, `.2`,
+ * ... on the same day. The plan lines print this same name before the write, so what the
+ * plan says and what the write does are one computation.
+ */
+function backupTarget(path) {
+    const stamp = today();
+    let candidate = `${path}.backup-${stamp}`;
+    for (let n = 1; lexists(candidate); n += 1)
+        candidate = `${path}.backup-${stamp}.${n}`;
+    return candidate;
+}
+/**
+ * Copy the file aside before changing it. Returns the copy, or `null` if there was none.
+ *
+ * Dated, so a person looking at their own config directory a week later can tell when it
+ * happened — and NEVER OVERWRITTEN (#138). Until job65 a second run on the same day wrote the
+ * same `<name>.backup-<date>` on purpose, "rather than growing a pile nobody prunes"; the
+ * README's undo promise is that the backup restores the file as it was BEFORE bantamkit
+ * touched it, and the second run was overwriting exactly that copy with the first run's
+ * output. A pile of dated copies is the price of an undo that works; the counter suffix is
+ * the price of keeping the documented name for the first one.
+ *
+ * `copyFileSync` follows a symlink on the source, so the copy holds the REAL file's bytes and
+ * sits beside the path the report names.
+ */
 function backup(path) {
     if (!existsSync(path))
         return null;
-    const target = `${path}.backup-${today()}`;
+    const target = backupTarget(path);
     try {
         copyFileSync(path, target);
     }
@@ -218,25 +410,26 @@ export function install(host, command, args, force = false) {
     const key = configKey(host);
     const wanted = entryFor(host, command, args);
     const data = readConfig(path);
-    const raw = data[key];
-    if (raw !== undefined && (raw === null || typeof raw !== 'object' || Array.isArray(raw))) {
+    const raw = data.v.get(key);
+    if (raw !== undefined && raw.t !== 'dict') {
         throw new InstallError(`${path} has a '${key}' that is not an object; refusing to touch it`);
     }
-    const servers = (raw ?? {});
-    const existing = servers[ENTRY];
-    if (existing !== undefined && dumps(existing, null, true) === dumps(wanted, null, true)) {
+    const servers = raw ?? pyDict();
+    // MEMBERSHIP, not a null test: `"bantamkit": null` is an entry (`PY_NONE`, not `undefined`).
+    const existing = servers.v.get(ENTRY);
+    if (existing !== undefined && dumpJson(existing, { sortKeys: true }) === dumps(wanted, null, true)) {
         return `bantamkit is already installed in ${host} and matches\n  file   : ${path}`;
     }
     if (existing !== undefined && !force) {
         throw new InstallError(`${host} already has a bantamkit entry with different settings\n` +
             `  file    : ${path}\n` +
-            `  current : ${dumps(existing, null, true)}\n` +
+            `  current : ${dumpJson(existing, { sortKeys: true })}\n` +
             `  proposed: ${dumps(wanted, null, true)}\n` +
             '  re-run with --force to replace it');
     }
     const copied = backup(path);
-    servers[ENTRY] = wanted;
-    data[key] = servers;
+    servers.v.set(ENTRY, fromJs(wanted));
+    data.v.set(key, servers);
     writeConfig(path, data);
     const lines = [
         `installed bantamkit into ${host}`,
@@ -494,10 +687,13 @@ function hookEntry(matcher, command) {
     ];
     return entry;
 }
-/** A plain object — not null, not an array. The shape every test below needs first. */
-function isObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
+/** `{"event": [...]}` as a `PyValue`, for the one comparison and the one write that need it. */
+const asPyValue = (table) => ({ t: 'dict', v: new Map([...table].map(([event, entries]) => [event, { t: 'list', v: entries }])) });
+/** The `str` behind a key, or `undefined` when the key is absent or holds something else. */
+const strAt = (dict, key) => {
+    const value = dict.v.get(key);
+    return value !== undefined && value.t === 'str' ? value.v : undefined;
+};
 /**
  * The two command spellings bantamkit ever wrote, for entries that predate the marker.
  *
@@ -516,13 +712,17 @@ function isObject(value) {
  * third-party script with the word in its filename was claimed as ours and deleted.
  */
 function isLegacyOurs(hook) {
-    if (hook['type'] !== 'command')
+    if (strAt(hook, 'type') !== 'command')
         return false;
-    const command = hook['command'];
-    if (typeof command !== 'string' || !command.includes('bantamkit'))
+    const command = strAt(hook, 'command');
+    if (command === undefined || !command.includes('bantamkit'))
         return false;
     return command.includes('bantamkit-hook') || command === '--hook' || command.endsWith(' --hook');
 }
+/** ONE inner hook object: ours by marker, or by one of the two legacy spellings. */
+function isOurHook(hook) {
+    return hook.t === 'dict' && (hook.v.has(HOOK_MARKER_KEY) || isLegacyOurs(hook));
+}
 /**
  * RULING Q3.6's idempotence rule, RE-DECIDED ON THE ENTRY ALONE (J62-22).
  *
@@ -539,60 +739,96 @@ function isLegacyOurs(hook) {
  * shapes we wrote before the marker existed. Where any binary lives is not consulted.
  */
 function isOurs(entry) {
-    if (!isObject(entry))
+    if (entry.t !== 'dict')
         return false;
-    const hooks = entry['hooks'];
-    if (!Array.isArray(hooks))
+    const hooks = entry.v.get('hooks');
+    if (hooks === undefined || hooks.t !== 'list')
         return false;
-    return hooks.some((hook) => isObject(hook) && (HOOK_MARKER_KEY in hook || isLegacyOurs(hook)));
+    return hooks.v.some(isOurHook);
+}
+/**
+ * `entry` with bantamkit's own command objects taken out, and how many came out.
+ *
+ * THE UNIT OF OWNERSHIP IS THE COMMAND OBJECT, NOT THE MATCHER BLOCK (#129). `isOurs` answers
+ * "does this block hold one of ours", and dropping the whole block on that answer deleted a
+ * user's `notify-send` that shared the block with ours — after a plan that had just promised
+ * their hooks were left byte for byte. So: a block that is not ours comes back untouched (the
+ * same object, nothing removed); a block that holds ours loses ONLY those objects and keeps
+ * every other key it had; and a block left with no hooks at all is `null`, because
+ * `{"matcher": ..., "hooks": []}` is an artefact nobody wrote.
+ */
+function withoutOurs(entry) {
+    if (!isOurs(entry) || entry.t !== 'dict')
+        return [entry, 0];
+    const hooks = entry.v.get('hooks');
+    if (hooks === undefined || hooks.t !== 'list')
+        return [entry, 0];
+    const kept = hooks.v.filter((hook) => !isOurHook(hook));
+    const removed = hooks.v.length - kept.length;
+    if (kept.length === 0)
+        return [null, removed];
+    const trimmed = pyDict(entry.v);
+    trimmed.v.set('hooks', { t: 'list', v: kept });
+    return [trimmed, removed];
 }
 /** The `hooks` object, validated. Refuses by name rather than crashing on somebody's file. */
 function readHooks(path, data) {
-    const raw = data['hooks'];
+    const raw = data.v.get('hooks');
     if (raw === undefined)
-        return {};
-    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+        return new Map();
+    if (raw.t !== 'dict') {
         throw new InstallError(`${path} has a 'hooks' that is not an object; refusing to touch it`);
     }
-    const hooks = {};
-    for (const [event, entries] of Object.entries(raw)) {
-        if (!Array.isArray(entries)) {
+    const hooks = new Map();
+    for (const [event, entries] of raw.v) {
+        if (entries.t !== 'list') {
             throw new InstallError(`${path} has a 'hooks.${event}' that is not a list; refusing to touch it`);
         }
-        hooks[event] = [...entries];
+        hooks.set(event, [...entries.v]);
     }
     return hooks;
 }
 /**
- * The `hooks` object this run wants, built from whatever is there now.
+ * The `hooks` object this run wants, built from whatever is there now, the events that change,
+ * and how many of OUR command objects came out.
  *
- * ONE PASS OVER THE SEVEN EVENTS AND NOTHING ELSE: every event keeps its non-bantamkit entries
- * in their existing order, ours is appended after them, and an event left with none loses its
- * key rather than holding an empty list — `install.mjs`'s rule, kept because a settings file
- * full of empty arrays is a worse artefact than one with nothing in it.
+ * ONE PASS OVER THE SEVEN EVENTS AND NOTHING ELSE: every event keeps its non-bantamkit hooks in
+ * their existing order and their existing blocks, ours is appended after them, and an event
+ * left with none loses its key rather than holding an empty list — `install.mjs`'s rule, kept
+ * because a settings file full of empty arrays is a worse artefact than one with nothing in
+ * it. A block is dropped only when taking ours out of it leaves it empty (`withoutOurs`).
  *
  * Events outside the seven are not read, not reordered and not removed.
  */
 function plannedHooks(current, command, remove) {
-    const hooks = { ...current };
+    const hooks = new Map(current);
     const touched = [];
+    let removed = 0;
     for (const [event, matcher] of HOOK_EVENTS) {
-        const before = hooks[event] ?? [];
-        const kept = before.filter((entry) => !isOurs(entry));
+        const before = hooks.get(event) ?? [];
+        const kept = [];
+        let removedHere = 0;
+        for (const entry of before) {
+            const [trimmed, count] = withoutOurs(entry);
+            removedHere += count;
+            if (trimmed !== null)
+                kept.push(trimmed);
+        }
+        removed += removedHere;
         if (remove) {
-            if (kept.length !== before.length)
+            if (removedHere > 0)
                 touched.push(event);
         }
         else {
-            kept.push(hookEntry(matcher, command));
+            kept.push(fromJs(hookEntry(matcher, command)));
             touched.push(event);
         }
         if (kept.length > 0)
-            hooks[event] = kept;
+            hooks.set(event, kept);
         else
-            delete hooks[event];
+            hooks.delete(event);
     }
-    return { hooks, touched };
+    return { hooks, touched, removed };
 }
 const EVENT_NAMES = HOOK_EVENTS.map(([event]) => event).join(' ');
 /**
@@ -610,7 +846,7 @@ function hookPlan(path, command) {
         `  command: ${command}`,
     ];
     if (existsSync(path))
-        lines.push(`  backup : ${path}.backup-${today()}`);
+        lines.push(`  backup : ${backupTarget(path)}`);
     lines.push("Existing hooks are left byte-for-byte; only bantamkit's own entries are replaced.");
     return `${lines.join('\n')}\n`;
 }
@@ -631,7 +867,7 @@ function removalPlan(path, events, entries) {
     return ([
         `bantamkit would remove ${entries} hook entries from ${path}`,
         `  events : ${events.join(' ')}`,
-        `  backup : ${path}.backup-${today()}`,
+        `  backup : ${backupTarget(path)}`,
         "Existing hooks are left byte-for-byte; only bantamkit's own entries are removed.",
     ].join('\n') + '\n');
 }
@@ -651,8 +887,8 @@ function removalPlan(path, events, entries) {
  *   5. dated backup, then one atomic write.
  *
  * The write itself is `writeConfig` — the same temp-file replace, the same carried mode, the
- * same `indent: 2` through `dumps` — so the bytes this leaves and the bytes `--install` leaves
- * are produced by one function (RULING Q3.5).
+ * same detected indent and literal non-ASCII through `hostJsonText` (#118) — so the bytes this
+ * leaves and the bytes `--install` leaves are produced by one function (RULING Q3.5).
  */
 export function installHooks(options = {}) {
     const { command, args } = thisCommand(options);
@@ -661,7 +897,7 @@ export function installHooks(options = {}) {
     const data = readConfig(path);
     const current = readHooks(path, data);
     const { hooks } = plannedHooks(current, rendered, false);
-    if (dumps(hooks, null, true) === dumps(current, null, true)) {
+    if (dumpJson(asPyValue(hooks), { sortKeys: true }) === dumpJson(asPyValue(current), { sortKeys: true })) {
         return `bantamkit hooks are already installed in ${path} and match`;
     }
     const tell = options.tell ?? (() => { });
@@ -681,7 +917,7 @@ export function installHooks(options = {}) {
         tell(hookPlan(path, rendered));
     }
     const copied = backup(path);
-    data['hooks'] = hooks;
+    data.v.set('hooks', asPyValue(hooks));
     writeConfig(path, data);
     const lines = [
         `installed bantamkit hooks into ${path}`,
@@ -721,14 +957,12 @@ export function removeHooks(options = {}) {
     const path = claudeSettingsPath();
     const data = readConfig(path);
     const current = readHooks(path, data);
-    const { hooks, touched } = plannedHooks(current, '', true);
+    const { hooks, touched, removed: entries } = plannedHooks(current, '', true);
     if (touched.length === 0)
         return `no bantamkit hooks are installed in ${path}`;
-    // Entries, not events: an event can hold more than one of ours if somebody hand-edited the
-    // file, and the plan has to say what is actually going.
-    let entries = 0;
-    for (const event of touched)
-        entries += (current[event] ?? []).length - (hooks[event] ?? []).length;
+    // `entries` counts OUR COMMAND OBJECTS, not events and not matcher blocks: an event can hold
+    // more than one of ours if somebody hand-edited the file, and a block that also holds a
+    // user's hook stays while ours leaves it (#129) — the plan has to say what is actually going.
     const tell = options.tell ?? (() => { });
     const yes = options.yes ?? false;
     const ask = options.ask ?? null;
@@ -746,7 +980,7 @@ export function removeHooks(options = {}) {
         tell(removalPlan(path, touched, entries));
     }
     const copied = backup(path);
-    data['hooks'] = hooks;
+    data.v.set('hooks', asPyValue(hooks));
     writeConfig(path, data);
     const lines = [`removed bantamkit hooks from ${path}`, `  events : ${touched.join(' ')}`];
     if (copied !== null)

package/dist/index.d.ts

@@ -2,8 +2,8 @@ export { BantamError } from './errors.js';
 export { ContractParseError, extractJson, loadContract, parseContractDocument, parseErrorMessage, REQUIRED_KEYS, schemaError, schemaRetryFeedback, validationErrorMessage, } from './contract.js';
 export { dumpJson, fromJs, PY_NONE, parseJson, pyFloatRepr, PyJSONDecodeError, PyValueError, rawDecode, reprValue, toJs, } from './pyjson.js';
 export type { DumpOptions, PyValue } from './pyjson.js';
-export { absolutePath, bestMatch, iterErrors, PyJsonSchemaUnsupported, pyEqual, validate, } from './pyjsonschema.js';
-export type { PyValidationError } from './pyjsonschema.js';
+export { absolutePath, bestMatch, iterErrors, PyJsonSchemaRefusal, PyJsonSchemaUnsupported, pyUrlNormalize, pyEqual, validate, } from './pyjsonschema.js';
+export type { Draft, PyValidationError } from './pyjsonschema.js';
 export { AssetNotFound, assetsRoot, loadSchema, loadSkill, loadTool, loadToolAsset } from './assets.js';
 export type { Tool } from './assets.js';
 export { decodeFactBytes, FactParseError, formatFact, parseFactText, parseFrontmatter, pySplit, pyStrip, todayLocal, } from './memory/factfile.js';

package/dist/index.js

@@ -1,7 +1,7 @@
 export { BantamError } from './errors.js';
 export { ContractParseError, extractJson, loadContract, parseContractDocument, parseErrorMessage, REQUIRED_KEYS, schemaError, schemaRetryFeedback, validationErrorMessage, } from './contract.js';
 export { dumpJson, fromJs, PY_NONE, parseJson, pyFloatRepr, PyJSONDecodeError, PyValueError, rawDecode, reprValue, toJs, } from './pyjson.js';
-export { absolutePath, bestMatch, iterErrors, PyJsonSchemaUnsupported, pyEqual, validate, } from './pyjsonschema.js';
+export { absolutePath, bestMatch, iterErrors, PyJsonSchemaRefusal, PyJsonSchemaUnsupported, pyUrlNormalize, pyEqual, validate, } from './pyjsonschema.js';
 export { AssetNotFound, assetsRoot, loadSchema, loadSkill, loadTool, loadToolAsset } from './assets.js';
 export { decodeFactBytes, FactParseError, formatFact, parseFactText, parseFrontmatter, pySplit, pyStrip, todayLocal, } from './memory/factfile.js';
 export { constructPlain, PyScalar, resolveImplicitTag, safeDumpMapping, YamlConstructError, YamlEmitError, } from './memory/pyyaml.js';

package/dist/mcp/identity.js

@@ -75,9 +75,35 @@ const unavailable = (reason) => ({ unavailable: reason });
  */
 function walkFiles(root) {
     const found = [];
+    // job66/#140: `rglob` over a root that is not a directory yields NOTHING — missing, a
+    // regular file, or a dangling link alike (`select_from` checks `is_dir()` first) — and it
+    // swallows `PermissionError` on any directory it cannot list. WAS: `readdirSync` threw, so
+    // `BANTAMKIT_ASSETS=<missing> --assets-root` died with a raw ENOENT stack where the
+    // reference prints `<path>` / `0 files` at exit 0. Measured on CPython 3.12:
+    // `list(Path("<missing>").rglob("*"))`, `<file>` and a mode-000 directory are all `[]`.
+    let rootIsDir = false;
+    try {
+        rootIsDir = statSync(root).isDirectory();
+    }
+    catch {
+        rootIsDir = false;
+    }
+    if (!rootIsDir)
+        return [];
+    const listing = (here) => {
+        try {
+            return readdirSync(here, { withFileTypes: true });
+        }
+        catch (e) {
+            const code = e.code;
+            if (code === 'EACCES' || code === 'EPERM')
+                return [];
+            throw e;
+        }
+    };
     const descend = (parts) => {
         const here = parts.length === 0 ? root : join(root, ...parts);
-        for (const entry of readdirSync(here, { withFileTypes: true })) {
+        for (const entry of listing(here)) {
             const next = [...parts, entry.name];
             if (entry.isDirectory()) {
                 descend(next);