@spikedpunch/mast 0.1.0

package/dist/telemetry/tokenizer.d.ts

@@ -0,0 +1,125 @@
+/**
+ * The honest tokenizer label, reported verbatim by `mast_efficiency`
+ * (`tokenizer` field) and the `mast metrics` footer.
+ *
+ * Single source of truth — every consumer reads this constant so the wording
+ * cannot drift. `@anthropic-ai/tokenizer@0.0.4` implements the Claude 2-era
+ * vocabulary and Anthropic never published Claude 3+ vocabularies, so absolute
+ * counts drift for every model that consumes MAST output today. The savings
+ * *ratio* mostly cancels the per-count error, which is why the mechanism stays
+ * and only the labeling is corrected (§14.5). An exact mode via the API's
+ * `count_tokens` endpoint is a documented future seam, not implemented here.
+ */
+export declare const TOKENIZER_LABEL = "@anthropic-ai/tokenizer (claude-2 era, approximate for current models)";
+/**
+ * Count tokens in `text` using `@anthropic-ai/tokenizer`.
+ *
+ * Used for `ToolStats.tokens_returned` and `tokens_full_file_upper_bound`.
+ * Counts are approximate for current models — see {@link TOKENIZER_LABEL}.
+ * The tokenizer loads its vocab table on first call and caches it in memory;
+ * subsequent calls are fast (microseconds).
+ */
+export declare function countTokens(text: string): number;
+/**
+ * Filesystem access needed by {@link estimateFullFileBound}, injected so
+ * tests can observe cache-hit / cache-miss behaviour deterministically
+ * (§4.4 — depend on an interface, not a `node:fs` module mock).
+ *
+ * `mtimeSeconds` and `sizeBytes` are returned from one `stat` method, not two
+ * — `fs.statSync` already yields both from a single syscall, and the budget
+ * path (F8) needs the size for every cache miss, so splitting them into
+ * `statMtime` + a hypothetical `statSize` would double the stat cost for no
+ * benefit.
+ */
+export interface FullFileReader {
+    /** Reads a file's full UTF-8 contents. Callers catch failures. */
+    readonly readFile: (absolutePath: string) => string;
+    /**
+     * Returns the file's mtime (unix epoch seconds, matching the `files` table
+     * convention — see `staleness.ts`) and size in bytes. Callers catch
+     * failures.
+     */
+    readonly stat: (absolutePath: string) => {
+        readonly mtimeSeconds: number;
+        readonly sizeBytes: number;
+    };
+}
+/**
+ * Upper bound on the full-file token cache. Tokenizing whole files is the
+ * expensive part of every read-tool call (§14.2), so repeated hits on the
+ * same unchanged file must not re-tokenize — but an unbounded cache would
+ * grow without limit across a long-running `mast serve` process.
+ *
+ * F8 (eval/GITNEXUS_COMPARISON.md §13.7): 200 was tuned for "one working
+ * session's file set", before `mast_project_skeleton` — which references
+ * EVERY project file — existed as a caller. Entries are a path string plus
+ * two numbers, a few hundred bytes each, so 8192 entries is ~2-3 MB worst
+ * case: comfortably covers the ~10k-file corpora at the 150k-chunk scale
+ * target (plan Stage 4.5), so repeated calls against a monorepo-sized
+ * project CONVERGE to all-exact counts (via the per-call tokenization
+ * budget below) instead of thrashing forever.
+ */
+export declare const FULL_FILE_BOUND_CACHE_LIMIT = 8192;
+/**
+ * Maximum number of cache-miss paths {@link estimateFullFileBound} will
+ * exactly read and tokenize in one call. Paths beyond this budget are
+ * size-estimated instead (see {@link BYTES_PER_TOKEN_ESTIMATE}).
+ *
+ * F8: measured ~24ms/file to read+tokenize a full file, so 32 files is
+ * ~0.8s worst-case telemetry overhead per call — versus the ~28s/call this
+ * function cost when it tokenized all 1,334 files in a monorepo-sized
+ * project on every `mast_project_skeleton` call. §14.1 sets telemetry's
+ * "negligible overhead" goal; whatever the exact bound, instrumentation must
+ * never cost more than the query it instruments, and this budget converts an
+ * unbounded, thrashing cost into a bounded, converging one.
+ */
+export declare const FULL_FILE_TOKENIZE_BUDGET_PER_CALL = 32;
+/**
+ * Bytes-per-token heuristic used to estimate the token count of a cache-miss
+ * path once {@link FULL_FILE_TOKENIZE_BUDGET_PER_CALL} is exhausted for a
+ * call. This is the standard ~4-bytes/token rule of thumb for source text —
+ * defensible here because `tokens_full_file_upper_bound` is already an
+ * explicitly approximate, upper-bound methodology number (the tokenizer
+ * itself is a claude-2-era vocabulary, §14.5 / {@link TOKENIZER_LABEL}), not
+ * a billing figure.
+ */
+export declare const BYTES_PER_TOKEN_ESTIMATE = 4;
+/**
+ * Test-only seam: seeds the full-file cache via the real `cacheTouch` insert
+ * + evict path, without paying for real tokenization.
+ *
+ * F8 raised {@link FULL_FILE_BOUND_CACHE_LIMIT} to 8192. Profiling showed
+ * `countTokens` costs ~22ms/call *regardless of content length* (a fixed
+ * per-invocation floor, not an I/O or content-size cost), so proving
+ * eviction still fires once the raised bound is exceeded — by driving 8192+
+ * real reads through {@link estimateFullFileBound} — would cost minutes and
+ * dwarf the very call this change speeds up. Seeding through `cacheTouch`
+ * exercises the exact same insert-and-evict-oldest branch production code
+ * uses; only the (irrelevant, for this purpose) cost of real tokenization is
+ * skipped. Not used by any non-test code.
+ */
+export declare function __seedFullFileCacheForTests(absolutePath: string, mtime: number, tokens: number): void;
+/**
+ * Estimate the full-file token upper bound for a set of file paths (§14.2).
+ *
+ * For each unique path, reads the full file under `projectRoot` and sums
+ * `countTokens` over its contents — the "what would a naive Read of every
+ * result file have cost?" counterfactual used to compute `efficiency_ratio`.
+ *
+ * Missing or unreadable files contribute 0 and never throw: the metrics path
+ * must never break a tool response over a stale or deleted file reference.
+ * Repeated calls referencing the same file at the same mtime reuse the
+ * cached token count instead of re-reading and re-tokenizing.
+ *
+ * F8 — "cap the work, not the cache" (eval/GITNEXUS_COMPARISON.md §13.7):
+ * a cache miss is only exactly tokenized while
+ * {@link FULL_FILE_TOKENIZE_BUDGET_PER_CALL} allows it, in the caller's path
+ * order (after dedup) so results are deterministic. Cache hits are free and
+ * never consume budget. Once the budget is exhausted for a call, further
+ * cache misses are size-estimated (`sizeBytes / BYTES_PER_TOKEN_ESTIMATE`)
+ * rather than read — and NOT cached, since an estimate must never masquerade
+ * as an exact cached count. Successive calls over the same path set
+ * progressively convert estimates to exact, cached counts.
+ */
+export declare function estimateFullFileBound(filePaths: readonly string[], projectRoot: string, reader?: FullFileReader): number;
+//# sourceMappingURL=tokenizer.d.ts.map

package/dist/telemetry/tokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenizer.d.ts","sourceRoot":"","sources":["../../src/telemetry/tokenizer.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,2EAC8C,CAAC;AAE3E;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,cAAc;IAC7B,kEAAkE;IAClE,QAAQ,CAAC,QAAQ,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,MAAM,CAAC;IACpD;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK;QAAE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CACxG;AAeD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAEhD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kCAAkC,KAAK,CAAC;AAErD;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAiB1C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAErG;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,WAAW,EAAE,MAAM,EACnB,MAAM,GAAE,cAAsC,GAC7C,MAAM,CA8CR"}

package/dist/telemetry/tokenizer.js

@@ -0,0 +1,174 @@
+import { readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { countTokens as anthropicCountTokens } from '@anthropic-ai/tokenizer';
+// ---------------------------------------------------------------------------
+// Token counting (@anthropic-ai/tokenizer — claude-2 era, approximate)
+// ---------------------------------------------------------------------------
+/**
+ * The honest tokenizer label, reported verbatim by `mast_efficiency`
+ * (`tokenizer` field) and the `mast metrics` footer.
+ *
+ * Single source of truth — every consumer reads this constant so the wording
+ * cannot drift. `@anthropic-ai/tokenizer@0.0.4` implements the Claude 2-era
+ * vocabulary and Anthropic never published Claude 3+ vocabularies, so absolute
+ * counts drift for every model that consumes MAST output today. The savings
+ * *ratio* mostly cancels the per-count error, which is why the mechanism stays
+ * and only the labeling is corrected (§14.5). An exact mode via the API's
+ * `count_tokens` endpoint is a documented future seam, not implemented here.
+ */
+export const TOKENIZER_LABEL = '@anthropic-ai/tokenizer (claude-2 era, approximate for current models)';
+/**
+ * Count tokens in `text` using `@anthropic-ai/tokenizer`.
+ *
+ * Used for `ToolStats.tokens_returned` and `tokens_full_file_upper_bound`.
+ * Counts are approximate for current models — see {@link TOKENIZER_LABEL}.
+ * The tokenizer loads its vocab table on first call and caches it in memory;
+ * subsequent calls are fast (microseconds).
+ */
+export function countTokens(text) {
+    return anthropicCountTokens(text);
+}
+const defaultFullFileReader = {
+    readFile: (absolutePath) => readFileSync(absolutePath, 'utf8'),
+    stat: (absolutePath) => {
+        const s = statSync(absolutePath);
+        return { mtimeSeconds: s.mtimeMs / 1_000, sizeBytes: s.size };
+    },
+};
+/**
+ * Upper bound on the full-file token cache. Tokenizing whole files is the
+ * expensive part of every read-tool call (§14.2), so repeated hits on the
+ * same unchanged file must not re-tokenize — but an unbounded cache would
+ * grow without limit across a long-running `mast serve` process.
+ *
+ * F8 (eval/GITNEXUS_COMPARISON.md §13.7): 200 was tuned for "one working
+ * session's file set", before `mast_project_skeleton` — which references
+ * EVERY project file — existed as a caller. Entries are a path string plus
+ * two numbers, a few hundred bytes each, so 8192 entries is ~2-3 MB worst
+ * case: comfortably covers the ~10k-file corpora at the 150k-chunk scale
+ * target (plan Stage 4.5), so repeated calls against a monorepo-sized
+ * project CONVERGE to all-exact counts (via the per-call tokenization
+ * budget below) instead of thrashing forever.
+ */
+export const FULL_FILE_BOUND_CACHE_LIMIT = 8192;
+/**
+ * Maximum number of cache-miss paths {@link estimateFullFileBound} will
+ * exactly read and tokenize in one call. Paths beyond this budget are
+ * size-estimated instead (see {@link BYTES_PER_TOKEN_ESTIMATE}).
+ *
+ * F8: measured ~24ms/file to read+tokenize a full file, so 32 files is
+ * ~0.8s worst-case telemetry overhead per call — versus the ~28s/call this
+ * function cost when it tokenized all 1,334 files in a monorepo-sized
+ * project on every `mast_project_skeleton` call. §14.1 sets telemetry's
+ * "negligible overhead" goal; whatever the exact bound, instrumentation must
+ * never cost more than the query it instruments, and this budget converts an
+ * unbounded, thrashing cost into a bounded, converging one.
+ */
+export const FULL_FILE_TOKENIZE_BUDGET_PER_CALL = 32;
+/**
+ * Bytes-per-token heuristic used to estimate the token count of a cache-miss
+ * path once {@link FULL_FILE_TOKENIZE_BUDGET_PER_CALL} is exhausted for a
+ * call. This is the standard ~4-bytes/token rule of thumb for source text —
+ * defensible here because `tokens_full_file_upper_bound` is already an
+ * explicitly approximate, upper-bound methodology number (the tokenizer
+ * itself is a claude-2-era vocabulary, §14.5 / {@link TOKENIZER_LABEL}), not
+ * a billing figure.
+ */
+export const BYTES_PER_TOKEN_ESTIMATE = 4;
+// Module-level so the cache survives across tool calls within one `mast
+// serve` process. Map iteration order is insertion order, so the first key
+// is always the least-recently-used one — cheap LRU-ish eviction with no
+// extra dependency (re-inserting a key on cache hit moves it to the tail).
+const fullFileCache = new Map();
+function cacheTouch(absolutePath, entry) {
+    fullFileCache.delete(absolutePath);
+    fullFileCache.set(absolutePath, entry);
+    if (fullFileCache.size > FULL_FILE_BOUND_CACHE_LIMIT) {
+        const oldestKey = fullFileCache.keys().next().value;
+        if (oldestKey !== undefined)
+            fullFileCache.delete(oldestKey);
+    }
+}
+/**
+ * Test-only seam: seeds the full-file cache via the real `cacheTouch` insert
+ * + evict path, without paying for real tokenization.
+ *
+ * F8 raised {@link FULL_FILE_BOUND_CACHE_LIMIT} to 8192. Profiling showed
+ * `countTokens` costs ~22ms/call *regardless of content length* (a fixed
+ * per-invocation floor, not an I/O or content-size cost), so proving
+ * eviction still fires once the raised bound is exceeded — by driving 8192+
+ * real reads through {@link estimateFullFileBound} — would cost minutes and
+ * dwarf the very call this change speeds up. Seeding through `cacheTouch`
+ * exercises the exact same insert-and-evict-oldest branch production code
+ * uses; only the (irrelevant, for this purpose) cost of real tokenization is
+ * skipped. Not used by any non-test code.
+ */
+export function __seedFullFileCacheForTests(absolutePath, mtime, tokens) {
+    cacheTouch(absolutePath, { mtime, tokens });
+}
+/**
+ * Estimate the full-file token upper bound for a set of file paths (§14.2).
+ *
+ * For each unique path, reads the full file under `projectRoot` and sums
+ * `countTokens` over its contents — the "what would a naive Read of every
+ * result file have cost?" counterfactual used to compute `efficiency_ratio`.
+ *
+ * Missing or unreadable files contribute 0 and never throw: the metrics path
+ * must never break a tool response over a stale or deleted file reference.
+ * Repeated calls referencing the same file at the same mtime reuse the
+ * cached token count instead of re-reading and re-tokenizing.
+ *
+ * F8 — "cap the work, not the cache" (eval/GITNEXUS_COMPARISON.md §13.7):
+ * a cache miss is only exactly tokenized while
+ * {@link FULL_FILE_TOKENIZE_BUDGET_PER_CALL} allows it, in the caller's path
+ * order (after dedup) so results are deterministic. Cache hits are free and
+ * never consume budget. Once the budget is exhausted for a call, further
+ * cache misses are size-estimated (`sizeBytes / BYTES_PER_TOKEN_ESTIMATE`)
+ * rather than read — and NOT cached, since an estimate must never masquerade
+ * as an exact cached count. Successive calls over the same path set
+ * progressively convert estimates to exact, cached counts.
+ */
+export function estimateFullFileBound(filePaths, projectRoot, reader = defaultFullFileReader) {
+    const uniquePaths = new Set(filePaths);
+    let total = 0;
+    let tokenizeBudgetRemaining = FULL_FILE_TOKENIZE_BUDGET_PER_CALL;
+    for (const relPath of uniquePaths) {
+        const absPath = join(projectRoot, relPath);
+        let mtimeSeconds;
+        let sizeBytes;
+        try {
+            ({ mtimeSeconds, sizeBytes } = reader.stat(absPath));
+        }
+        catch {
+            continue; // file missing/unreadable — contributes 0, consumes no budget
+        }
+        const cached = fullFileCache.get(absPath);
+        if (cached !== undefined && cached.mtime === mtimeSeconds) {
+            total += cached.tokens;
+            // Refresh recency even on a hit so a hot file survives eviction.
+            cacheTouch(absPath, cached);
+            continue;
+        }
+        if (tokenizeBudgetRemaining <= 0) {
+            // Beyond the per-call budget: estimate from size instead of paying for
+            // an exact read+tokenize. Deliberately not cached (see doc comment).
+            total += Math.ceil(sizeBytes / BYTES_PER_TOKEN_ESTIMATE);
+            continue;
+        }
+        // A failed read below still spends this slot rather than freeing it for
+        // the next path — the simplest honest rule, and consistent with the
+        // fact that the stat() that granted the slot already succeeded.
+        tokenizeBudgetRemaining--;
+        try {
+            const content = reader.readFile(absPath);
+            const tokens = countTokens(content);
+            cacheTouch(absPath, { mtime: mtimeSeconds, tokens });
+            total += tokens;
+        }
+        catch {
+            continue; // unreadable despite a successful stat — contributes 0
+        }
+    }
+    return total;
+}
+//# sourceMappingURL=tokenizer.js.map

package/dist/telemetry/tokenizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenizer.js","sourceRoot":"","sources":["../../src/telemetry/tokenizer.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@spikedpunch/mast",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SpikedPunchVictim/mast.git"
+  },
+  "homepage": "https://github.com/SpikedPunchVictim/mast#readme",
+  "bugs": {
+    "url": "https://github.com/SpikedPunchVictim/mast/issues"
+  },
+  "keywords": [
+    "mcp",
+    "code-search",
+    "ast",
+    "tree-sitter",
+    "monorepo",
+    "typescript",
+    "claude"
+  ],
+  "description": "MAST — Monorepo AST Search Tool: semantic code search MCP server and CLI",
+  "type": "module",
+  "bin": {
+    "mast": "./dist/cli/index.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/cli/index.js",
+      "types": "./dist/cli/index.d.ts"
+    },
+    "./graph": {
+      "import": "./dist/graph/index.js",
+      "types": "./dist/graph/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "assets",
+    "MAST_SPEC.md"
+  ],
+  "dependencies": {
+    "@anthropic-ai/tokenizer": "^0.0.4",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "better-sqlite3": "^12.10.0",
+    "chokidar": "^5.0.0",
+    "commander": "^14.0.3",
+    "fast-glob": "^3.3.3",
+    "kysely": "^0.29.0",
+    "proper-lockfile": "^4.1.2",
+    "tree-sitter": "0.22.4",
+    "tree-sitter-typescript": "0.23.2",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.3.0",
+    "uuid": "^14.0.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^24.0.0",
+    "@types/proper-lockfile": "^4.1.4",
+    "@typescript-eslint/eslint-plugin": "^8.60.1",
+    "@typescript-eslint/parser": "^8.60.1",
+    "eslint": "^10.4.1",
+    "vitest": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.test.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src eval",
+    "format": "prettier --write src"
+  }
+}