bantamkit-mcp 0.29.1 → 0.30.0

package/dist/eventlog.js

@@ -32,10 +32,11 @@
  *   one stray write breaks the wire suite. Nothing in this module names `process.stdout`,
  *   `process.stderr` or `console`.
  * * **Metadata only.** Never a tool argument's value, never a memory body, never a
- *   validated output, never a query, never a document row. Six of the eleven tools take
- *   unbounded free text and five take absolute paths (`bantamkit_read`'s `path` is one and
- *   `skill_audit`'s `root` is another; each record carries counts and tokens from a closed
- *   set — never the path, never a part name, never a skill id).
+ *   validated output, never a query, never a document row. Seven of the thirteen tools take
+ *   unbounded free text and six take absolute paths (`bantamkit_read`'s `path` is one,
+ *   `skill_audit`'s `root` is another and `repo_map`'s `root` and `focus` are the third;
+ *   each record carries counts and tokens from a closed set — never the path, never a part
+ *   name, never a skill id, never a mapped file).
  *   Every value written here is an ASCII token from a closed set, a number, or a boolean.
  * * **Never `String(err)`.** Only the constructor name. This is not hypothetical: the host
  *   itself has already persisted `input_value={'schema_path': '/Users/k...

package/dist/index.d.ts

@@ -13,11 +13,13 @@ export type { PyOrder, YamlScalar, YamlValue } from './memory/pyyaml.js';
 export { countFacts, discoverProjectStore, loadGrants, MEMORY_DIR_ENV, PROJECT_STORE, resolveProjectStore, } from './memory/layers.js';
 export type { StoreBinding } from './memory/layers.js';
 export { layerLabel, Memory, normalizeName, profileStore } from './memory/component.js';
-export type { CompactOutcome, MemoryOptions, RecallOutcome, SaveOutcome } from './memory/component.js';
+export type { CompactOutcome, DreamOutcome, MemoryOptions, RecallOutcome, SaveOutcome, } from './memory/component.js';
+export { absolutise, blockKey, claimSlot, collapse, dream, formatFixed3, mergeBodies, mergeDescriptions, mergeLinks, PROFILE_LAYER, PROJECT_LAYER, pyIntDigits, sortedNames, splitBlocks, SUPERSEDED_HEADING, } from './memory/dream.js';
+export type { DateHit, DreamMerge, DreamResult, SimilarPair, Superseded } from './memory/dream.js';
 export { CAP_BYTES, DEFAULT_RELATIVE_PATH, defaultPath, encodeRecord, EVENT_LOG_ENV, EventLog, formatTimestamp, resolvePath, SCHEMA_VERSION, } from './eventlog.js';
 export type { DetailValue } from './eventlog.js';
-export { DEFAULT_INDEX_BUDGET, DUPLICATE_JACCARD, jaccard, MemoryBudgetExceeded, MemoryStore, MemoryValidationError, pyCompareLt, pyEqualValue, pyHashKey, pyText, sortScored, tokens, VALID_TYPES, } from './memory/store.js';
-export type { MemoryStoreOptions, SaveResult } from './memory/store.js';
+export { DEFAULT_INDEX_BUDGET, DUPLICATE_JACCARD, jaccard, MemoryBudgetExceeded, MemoryStore, MemoryValidationError, pyCompareLt, pyEqualValue, pyHashKey, pyText, RECALL_MIN_SCORE_RATIO, sortScored, tokens, VALID_TYPES, } from './memory/store.js';
+export type { MemoryStoreOptions, SaveResult, StoreInternals } from './memory/store.js';
 export { asPyOSError, cmpCodepoint, matchesMd, normcase, pyDecodeUtf8, pyCwd, pyExists, pyExpanduser, pyHome, pyIsAbsolute, pyIsDir, pyIsFile, pyJoin, pyLexists, pyMkdirParents, pyMtimeDate, pyName, PyOSError, pyParent, pyParents, pyReadText, pyReplace, pyRepr, pyResolve, PyRuntimeError, pyScandirNames, PyUnicodeDecodeError, pyAppendText, pyStatIsDir, pySuffix, pyUnlink, pyWithSuffix, pyWriteText, sortedPathNames, sortedPathParts, STRERROR_NAMES, } from './memory/pyfs.js';
 export { clockIn, clockOut, HISTORY_RING_SIZE, SCHEMA_NAME, status, TERMINAL_UNIT_STATUS, timestamp, } from './shiftwork.js';
 export type { ClockOptions } from './shiftwork.js';

package/dist/index.js

@@ -7,7 +7,8 @@ export { decodeFactBytes, FactParseError, formatFact, parseFactText, parseFrontm
 export { constructPlain, PyScalar, resolveImplicitTag, safeDumpMapping, YamlConstructError, YamlEmitError, } from './memory/pyyaml.js';
 export { countFacts, discoverProjectStore, loadGrants, MEMORY_DIR_ENV, PROJECT_STORE, resolveProjectStore, } from './memory/layers.js';
 export { layerLabel, Memory, normalizeName, profileStore } from './memory/component.js';
+export { absolutise, blockKey, claimSlot, collapse, dream, formatFixed3, mergeBodies, mergeDescriptions, mergeLinks, PROFILE_LAYER, PROJECT_LAYER, pyIntDigits, sortedNames, splitBlocks, SUPERSEDED_HEADING, } from './memory/dream.js';
 export { CAP_BYTES, DEFAULT_RELATIVE_PATH, defaultPath, encodeRecord, EVENT_LOG_ENV, EventLog, formatTimestamp, resolvePath, SCHEMA_VERSION, } from './eventlog.js';
-export { DEFAULT_INDEX_BUDGET, DUPLICATE_JACCARD, jaccard, MemoryBudgetExceeded, MemoryStore, MemoryValidationError, pyCompareLt, pyEqualValue, pyHashKey, pyText, sortScored, tokens, VALID_TYPES, } from './memory/store.js';
+export { DEFAULT_INDEX_BUDGET, DUPLICATE_JACCARD, jaccard, MemoryBudgetExceeded, MemoryStore, MemoryValidationError, pyCompareLt, pyEqualValue, pyHashKey, pyText, RECALL_MIN_SCORE_RATIO, sortScored, tokens, VALID_TYPES, } from './memory/store.js';
 export { asPyOSError, cmpCodepoint, matchesMd, normcase, pyDecodeUtf8, pyCwd, pyExists, pyExpanduser, pyHome, pyIsAbsolute, pyIsDir, pyIsFile, pyJoin, pyLexists, pyMkdirParents, pyMtimeDate, pyName, PyOSError, pyParent, pyParents, pyReadText, pyReplace, pyRepr, pyResolve, PyRuntimeError, pyScandirNames, PyUnicodeDecodeError, pyAppendText, pyStatIsDir, pySuffix, pyUnlink, pyWithSuffix, pyWriteText, sortedPathNames, sortedPathParts, STRERROR_NAMES, } from './memory/pyfs.js';
 export { clockIn, clockOut, HISTORY_RING_SIZE, SCHEMA_NAME, status, TERMINAL_UNIT_STATUS, timestamp, } from './shiftwork.js';

package/dist/mcp/pyargs.d.ts

@@ -31,7 +31,7 @@ import { type PyValue } from '../pyjson.js';
 /** What a parameter accepts. `optional` is `| None = None` in the signature. */
 export interface FieldSpec {
     readonly name: string;
-    readonly kind: 'str' | 'int' | 'dict' | 'dictInt' | 'dictStr' | 'listStr';
+    readonly kind: 'str' | 'int' | 'bool' | 'dict' | 'dictInt' | 'dictStr' | 'listStr';
     readonly optional: boolean;
     /** `Field(le=...)`: an inclusive ceiling, checked AFTER the lax int parse succeeds. */
     readonly le?: bigint;
@@ -41,6 +41,25 @@ export interface ArgModel {
     readonly model: string;
     readonly fields: readonly FieldSpec[];
 }
+/**
+ * `assets/tools/bantamkit_read.json` `offset.maximum` — `Number.MAX_SAFE_INTEGER`, the
+ * largest integer `JSON.parse` reads back unchanged (F1). The reference binds it as
+ * `Annotated[int, Field(le=OFFSET_MAXIMUM)]`, so above it the refusal is pydantic's
+ * `less_than_equal` frame and the handler never runs; this side reads the JSON with its
+ * own decoder, so `9007199254740993` arrives exact and is refused with the same text.
+ *
+ * EXPORTED so the number can be TIED to the asset rather than copied a fourth time.
+ * `assets/tools/bantamkit_read.json` is the published contract and this is the number the
+ * signature enforces; `test/document-cache-and-bounds.test.mjs` reads that file OFF DISK and
+ * compares it against this constant, against the schema the server actually serves, and
+ * against what the handler refuses — the port of `runtime-py`'s
+ * `tests/test_document_manifest_parity.py`. Register entries (c) and (l),
+ * `docs/roadmap-toolbox.md` row 8. It stays a test rather than a runtime read for the
+ * reference's reason: a module-level asset load would make importing this module fail
+ * wherever the asset pack is not on disk, which is a worse failure than a refusal to
+ * register a tool.
+ */
+export declare const OFFSET_MAXIMUM = 9007199254740991n;
 /**
  * One model per handler, mirroring `build_server`'s closures signature for signature.
  *

package/dist/mcp/pyargs.js

@@ -41,8 +41,19 @@ const opt = (name, kind, bound = {}) => ({
  * `Annotated[int, Field(le=OFFSET_MAXIMUM)]`, so above it the refusal is pydantic's
  * `less_than_equal` frame and the handler never runs; this side reads the JSON with its
  * own decoder, so `9007199254740993` arrives exact and is refused with the same text.
+ *
+ * EXPORTED so the number can be TIED to the asset rather than copied a fourth time.
+ * `assets/tools/bantamkit_read.json` is the published contract and this is the number the
+ * signature enforces; `test/document-cache-and-bounds.test.mjs` reads that file OFF DISK and
+ * compares it against this constant, against the schema the server actually serves, and
+ * against what the handler refuses — the port of `runtime-py`'s
+ * `tests/test_document_manifest_parity.py`. Register entries (c) and (l),
+ * `docs/roadmap-toolbox.md` row 8. It stays a test rather than a runtime read for the
+ * reference's reason: a module-level asset load would make importing this module fail
+ * wherever the asset pack is not on disk, which is a worse failure than a refusal to
+ * register a tool.
  */
-const OFFSET_MAXIMUM = 9007199254740991n;
+export const OFFSET_MAXIMUM = 9007199254740991n;
 /**
  * One model per handler, mirroring `build_server`'s closures signature for signature.
  *
@@ -115,6 +126,28 @@ export const ARG_MODELS = {
     // `dict[str, str]`, and the reason `dictStr` exists beside it: a `str` field is STRICT even
     // in lax mode, so `{'a': 1}` is `versions.a` / `string_type` where the same value under
     // `usage` would validate.
+    // `dry_run: bool | None = None` on the reference (job45 row 5). LAX bool, and every arm
+    // below was MEASURED against the real stdio server, not read off pydantic's docs
+    // (`scratchpad` probe, 33 inputs): `0`/`1` and `0.0`/`1.0` coerce; any OTHER integral
+    // number — `2`, `-1`, `2.0` — is `bool_parsing`; a FRACTIONAL float is `bool_type`, a
+    // different frame from the integral one and the reason the float arm is split; a string
+    // is matched case-insensitively against two closed sets and is NOT stripped first, so
+    // `'true'` validates and `' true '` is `bool_parsing`; `''` is `bool_parsing`; a list or a
+    // dict is `bool_type`; and an explicit `null` is the default.
+    memory_dream: { model: 'memory_dreamArguments', fields: [opt('dry_run', 'bool')] },
+    // `repo_map(root: str, focus: list[str] | None = None, budget: int | None = None)` on
+    // the reference (job45 row 10). `root` is the strict `str` every other string field is —
+    // `123` is `string_type`. `focus` is the same `list[str]` as `skill_audit`'s `enabled`,
+    // so a non-list is `list_type` and a list holding a non-string is `focus.0` /
+    // `string_type`. `budget` is the lax `int` that `k`, `reserve` and `limit` are: `'2'`,
+    // `True` and `3.0` validate, `'2.5'` is `int_parsing`, `2.5` is `int_from_float`, and an
+    // explicit `null` is the default. No `le`, because the reference binds none — the
+    // manifest's `minimum: 0` is advisory to the client and the handler's own refusal is the
+    // negative one, exactly as `skill_audit`'s `budget` works.
+    repo_map: {
+        model: 'repo_mapArguments',
+        fields: [req('root', 'str'), opt('focus', 'listStr'), opt('budget', 'int')],
+    },
     skill_audit: {
         model: 'skill_auditArguments',
         fields: [
@@ -167,6 +200,13 @@ function truncateRepr(text) {
         tail += 1;
     return `${decoder.decode(bytes.slice(0, head))}...${decoder.decode(bytes.slice(tail))}`;
 }
+/**
+ * The two closed sets pydantic-core matches a string against for a lax `bool`, lowercased.
+ *
+ * No stripping: `' true '` is `bool_parsing` on the reference, measured over the wire.
+ */
+const BOOL_TRUE = new Set(['1', 'on', 't', 'true', 'y', 'yes']);
+const BOOL_FALSE = new Set(['0', 'off', 'f', 'false', 'n', 'no']);
 /** i64, which is the width pydantic parses an int into before it complains about size. */
 const I64_MAX = 9223372036854775807n;
 const I64_MIN = -9223372036854775808n;
@@ -247,6 +287,45 @@ function checkField(spec, value) {
             }
             return bad.length > 0 ? bad : { value };
         }
+        case 'bool': {
+            const parsing = () => [
+                {
+                    loc: spec.name,
+                    type: 'bool_parsing',
+                    msg: 'Input should be a valid boolean, unable to interpret input',
+                    input: value,
+                },
+            ];
+            const wrongType = () => [
+                { loc: spec.name, type: 'bool_type', msg: 'Input should be a valid boolean', input: value },
+            ];
+            if (value.t === 'bool')
+                return { value };
+            if (value.t === 'int') {
+                if (value.v === 0n || value.v === 1n)
+                    return { value: { t: 'bool', v: value.v === 1n } };
+                return parsing();
+            }
+            if (value.t === 'float') {
+                // A FRACTIONAL float is `bool_type` and an out-of-range integral one is
+                // `bool_parsing`. Measured, and not a distinction anyone would guess: `0.5` and
+                // `2.0` are both floats and they refuse under different frames.
+                if (!Number.isInteger(value.v))
+                    return wrongType();
+                if (value.v === 0 || value.v === 1)
+                    return { value: { t: 'bool', v: value.v === 1 } };
+                return parsing();
+            }
+            if (value.t === 'str') {
+                const key = value.v.toLowerCase();
+                if (BOOL_TRUE.has(key))
+                    return { value: { t: 'bool', v: true } };
+                if (BOOL_FALSE.has(key))
+                    return { value: { t: 'bool', v: false } };
+                return parsing();
+            }
+            return wrongType();
+        }
         case 'int': {
             const checked = checkInt(spec.name, value);
             if (!('value' in checked))

package/dist/mcp/server.d.ts

@@ -1,17 +1,19 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import * as repomap from '../repomap.js';
 import { EventLog } from '../eventlog.js';
 import type { Memory } from '../memory/component.js';
 import type { RawStdioTransport } from './transport.js';
 /**
- * The eleven, in the order `build_server` lists them — which is the order `tools/list` emits.
+ * The thirteen, in the order `build_server` lists them — which is the order `tools/list` emits.
  *
  * `bantamkit_status` went LAST rather than first, `memory_compact` after it rather than
- * beside `memory_save` where a reader would look for it, `bantamkit_read` after that and
- * `skill_audit` after that, for the same reason the reference appends all four: registration
- * order IS the served order, and appending is the only edit that leaves the other ten where
- * every existing declaration says they are.
+ * beside `memory_save` where a reader would look for it, `bantamkit_read` after that,
+ * `skill_audit` after that, `memory_dream` after that and `repo_map` after that, for the
+ * same reason the reference appends all six: registration order IS the served order, and
+ * appending is the only edit that leaves the other twelve where every existing declaration
+ * says they are.
  */
-export declare const MCP_TOOLS: readonly ["memory_save", "memory_recall", "validate_json", "shiftwork_clock_in", "shiftwork_clock_out", "shiftwork_status", "build_identity", "bantamkit_status", "memory_compact", "bantamkit_read", "skill_audit"];
+export declare const MCP_TOOLS: readonly ["memory_save", "memory_recall", "validate_json", "shiftwork_clock_in", "shiftwork_clock_out", "shiftwork_status", "build_identity", "bantamkit_status", "memory_compact", "bantamkit_read", "skill_audit", "memory_dream", "repo_map"];
 /**
  * The advertisement for one tool, out of its manifest, with the surface checked.
  *
@@ -28,6 +30,34 @@ export declare const MCP_TOOLS: readonly ["memory_save", "memory_recall", "valid
  * that detects drift. Registered here, not fixed here; `runtime-py` is the reference.
  */
 export declare function fromManifest(name: string): Record<string, unknown>;
+/**
+ * The last paragraph of every `repo_map` reply, refusal excepted. FIXED AND MANDATORY, and
+ * byte-identical to the reference's `REPO_MAP_TAIL`.
+ *
+ * Roadmap row 10's build gate was "build only after #4 shows discovery tokens dominate",
+ * and #4 REFUTED it: discovery is 0.114 % of real prompt tokens because 97.8 % of the bill
+ * is `cache_read`. The feature ships on an explicit ruling to build it anyway, as a
+ * PRECISION feature. A surface that let a caller believe the map is a token saving would
+ * say the one thing the measurement forbids, so the refutation travels with every answer
+ * rather than living only in a doc nobody reads at call time.
+ *
+ * The second sentence is the budget's unit, for the same reason: `DEFAULT_BUDGET = 4000` is
+ * "1 K tokens" only at the char/4 convention, whose error bar is unmeasured because
+ * measuring it needs the tokenizer the pure-node ruling forbids.
+ */
+export declare const REPO_MAP_TAIL: string;
+/** What a listing says when there is nothing to list. The reference's `REPO_MAP_EMPTY`. */
+export declare const REPO_MAP_EMPTY = "(nothing listed: no file under this root scanned into a definition)";
+/**
+ * The `repo_map` tool's prose, byte for byte, from the structured result.
+ *
+ * Split out of the handler for the same reason the reference splits `repo_map_reply` out of
+ * its own: one shape to reproduce rather than a format string buried in a `case`, and the
+ * `repomap` conformance suite compares the rendered reply without standing up a server. No
+ * float is ever rendered here — `repomap`'s trap (8); every number on the header line is an
+ * integer, and `String(1.0)` is `'1'` where `repr(1.0)` is `'1.0'`.
+ */
+export declare function repoMapReply(result: repomap.RepoMap): string;
 /**
  * Assemble the MCP server around one Memory instance (the per-person state).
  *