@smeltjs/core 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,298 @@
+/** Languages smelt can parse structurally. Everything else falls back to the lexical planner. */
+export type LanguageId = 'typescript' | 'tsx' | 'javascript' | 'rust' | 'python' | 'go' | 'java' | 'c' | 'cpp' | 'c_sharp' | 'ruby' | 'php' | 'kotlin' | 'swift' | 'bash';
+/** `'unknown'` is a first-class outcome, not a failure: it selects the lexical planner. */
+export type DetectedLanguage = LanguageId | 'unknown';
+/** A half-open byte range `[start, end)` into the UTF-8 bytes of the input. */
+export interface ByteRange {
+    readonly start: number;
+    readonly end: number;
+}
+/**
+ * Why a range was elided, in two registers: a stable id for counters, and a sentence
+ * a human can read in a diff. Law 2 — every elision is explainable — lives here:
+ * if you cannot write the sentence, the rule does not ship.
+ */
+export interface ElisionReason {
+    /** Stable machine id, e.g. `'sibling-collapse'`, `'line-window'`. */
+    readonly rule: string;
+    /** e.g. `'collapsed 3 sibling functions'`. Present tense, no trailing period. */
+    readonly explanation: string;
+}
+/** One range a planner proposes to remove. Plans are pure data — inspectable and testable. */
+export interface PlannedElision {
+    readonly range: ByteRange;
+    readonly reason: ElisionReason;
+}
+/**
+ * The complete output of a planner: the whole decision, before anything is mutated.
+ * A plan can be logged, diffed, snapshot-tested, and rejected without touching the text.
+ */
+export interface ElisionPlan {
+    readonly planner: string;
+    readonly language: DetectedLanguage;
+    readonly elisions: readonly PlannedElision[];
+}
+/**
+ * The seam through which a planner asks what a marker will cost, in UTF-8 bytes.
+ *
+ * Marker cost is `apply.ts`'s fact — the applier renders the marker, so only the
+ * applier knows its price. Planners need that price for two decisions (profitability:
+ * a marker that costs more than it removes grows the output; and budget prediction:
+ * which ladder rung actually fits), and before this seam each planner rebuilt the
+ * marker machinery privately to measure it — correct, but an inversion. Now
+ * `markerPricing()` in `apply.ts` builds the one adapter from the exact builder
+ * `applyPlan` will use, and planners ask it. They never guess, and they never render
+ * a marker of their own.
+ *
+ * The price is exact, not an estimate: the cost of the marker this elision would
+ * earn, comment leader and all, with a stand-in hash of the real hash's length —
+ * marker cost depends on the hash's *length*, never its value.
+ */
+export interface MarkerPricing {
+    /** The exact UTF-8 byte cost of the marker an elision with this reason and size would earn. */
+    costBytes(reason: ElisionReason, elidedBytes: number): number;
+}
+/**
+ * What the caller hands a planner.
+ *
+ * Constructed centrally: `createSmelter` (and through it, the CLI) builds the one
+ * `PlanInput` per call, including its {@link MarkerPricing} — a caller invoking
+ * `planLexical`/`planStructural` directly builds `pricing` with `markerPricing()`
+ * from `apply.ts`. A JS caller who omits it gets {@link MissingMarkerPricingError}
+ * at plan time, not a guessed cost.
+ */
+export interface PlanInput {
+    readonly text: string;
+    readonly language: DetectedLanguage;
+    /** Soft ceiling for the emitted output, in UTF-8 bytes. Planners aim under it. */
+    readonly budgetBytes: number;
+    /**
+     * What the caller was actually looking for — grep pattern, symbol name, error string.
+     * Planners keep matching regions and collapse around them.
+     */
+    readonly focus?: readonly string[];
+    /**
+     * What a marker costs. Required: a planner that guesses marker cost can plan an
+     * elision that grows the output. See {@link MarkerPricing}; built by
+     * `markerPricing()` in `apply.ts` from the exact builder `applyPlan` will use.
+     */
+    readonly pricing: MarkerPricing;
+}
+/**
+ * A planner decides *what* to remove. It never removes anything itself; `applyPlan`
+ * does that. Keeping the decision and the mutation apart is what makes the decision
+ * testable in isolation.
+ */
+export interface Planner {
+    readonly id: string;
+    plan(input: PlanInput): Promise<ElisionPlan>;
+}
+/** One elision that actually happened, with the receipt needed to undo it. */
+export interface AppliedElision {
+    /** Content hash of the removed bytes — the key `retrieve()` takes. */
+    readonly hash: string;
+    /** Where the removed bytes were in the *input*. */
+    readonly range: ByteRange;
+    /**
+     * Where the marker sits in the *output*. Law 3 — every elision is reversible — needs
+     * this: {@link Reconstructor} splices stored bytes back over these ranges. Without it,
+     * "reversible" would mean parsing markers back out of the text, which is a guess.
+     * This is a fact recorded at the moment of the cut.
+     */
+    readonly outputRange: ByteRange;
+    /** Size of the removed content, in UTF-8 bytes. */
+    readonly bytes: number;
+    readonly reason: ElisionReason;
+    /** The exact marker text substituted into the output. */
+    readonly marker: string;
+}
+/**
+ * A consumer-supplied counter, so a caller who bills in tokens can *see* tokens.
+ *
+ * Budgets in smelt's core are UTF-8 bytes, permanently — bytes are the only unit that
+ * is computable locally for every model, and they mean the same thing in five years.
+ * See `docs/HANDOFF.md` § "Decision 1". This hook does not change that: it adds a
+ * second, labelled number to the result. The plan is still made in bytes.
+ *
+ * Both `id` and `unit` are required, and that is a Law 4 decision rather than
+ * bookkeeping: a token count is meaningless without naming the tokenizer that produced
+ * it. Anthropic's own docs record that Claude 4.7 and later use a newer tokenizer where
+ * the same text yields roughly 30% more tokens than on earlier models — so `1,204
+ * tokens` is not a fact, and `1,204 tokens (claude-4.7/count_tokens)` is.
+ *
+ * **This hook does not relax Law 1.** smelt imports no transport and the guard proves
+ * that about smelt's own modules; it cannot prove it about a function you hand in. A
+ * `count()` that calls an API makes *your* process call an API, from a line in *your*
+ * source — exactly the arrangement {@link RerankStage} already describes. `count` is
+ * synchronous on purpose: local tokenizers are synchronous, and network clients are not.
+ */
+export interface Measure {
+    /** Names the counter, e.g. `'tiktoken/o200k_base'` or `'claude-4.7/count_tokens'`. */
+    readonly id: string;
+    /** The unit `count()` returns, e.g. `'tokens'`. Printed next to the number. */
+    readonly unit: string;
+    /** Local, synchronous count over the whole string. */
+    count(text: string): number;
+}
+/** A second size for a result, in someone else's unit, with the counter named. */
+export interface MeasuredSize {
+    /** {@link Measure.id} of the counter that produced these numbers. */
+    readonly measure: string;
+    /** {@link Measure.unit}. */
+    readonly unit: string;
+    readonly input: number;
+    readonly output: number;
+}
+/** The result of smelting one blob of text. */
+export interface SmeltResult {
+    readonly text: string;
+    readonly inputBytes: number;
+    readonly outputBytes: number;
+    readonly planner: string;
+    readonly language: DetectedLanguage;
+    readonly elisions: readonly AppliedElision[];
+    /** Present only when the caller supplied a {@link Measure}. Never invented. */
+    readonly measured?: MeasuredSize;
+}
+/** Options for a single `smelt()` call. */
+export interface SmeltOptions {
+    /** Soft ceiling for the emitted output, in UTF-8 bytes. */
+    readonly budgetBytes: number;
+    /** Filename or path, used to detect the language. Optional; detection falls back to `'unknown'`. */
+    readonly path?: string;
+    /** Override language detection entirely. */
+    readonly language?: DetectedLanguage;
+    /** What the caller was looking for. See {@link PlanInput.focus}. */
+    readonly focus?: readonly string[];
+}
+/**
+ * Reversibility, as a callable. Takes a {@link SmeltResult} and the store that holds its
+ * elided bytes, and returns the original text — byte for byte.
+ */
+export type Reconstructor = (result: SmeltResult, store: ElisionStore) => string;
+/**
+ * The numbers that keep smelt honest about itself.
+ *
+ * Law 3 says elisions are reversible. That is cheap to satisfy and easy to abuse: a
+ * compressor that cuts everything is "reversible" and useless. The *retrieve rate* is
+ * the tell. If the model keeps calling `smelt_retrieve`, smelt cut material the task
+ * needed, and the round trip cost more tokens than the elision saved.
+ *
+ * So: `expansionRate` is not telemetry. It is the metric a caller tunes budgets
+ * against, and the only number smelt is willing to have an opinion about — because it
+ * measures it locally, per session, on the caller's own traffic.
+ */
+export interface RetrieveStats {
+    /** Distinct blobs put into the store. */
+    readonly elisionsStored: number;
+    /** Total bytes held by the store. */
+    readonly bytesStored: number;
+    /** Every `retrieve()` call, including repeats and misses. */
+    readonly retrieveCalls: number;
+    /** Distinct hashes successfully retrieved at least once. */
+    readonly uniqueRetrieved: number;
+    /** Calls for a hash the store does not hold. Non-zero means a bug, not over-pruning. */
+    readonly misses: number;
+    /**
+     * `uniqueRetrieved / elisionsStored`, or `0` when nothing has been stored.
+     *
+     * Read it as: *what fraction of what smelt hid did the model have to ask for back?*
+     * There is no universally right value, and smelt does not ship a threshold it has
+     * not measured. Rising across a workload is the signal.
+     */
+    readonly expansionRate: number;
+    /**
+     * The one degenerate outcome smelt is willing to name: **every distinct blob it hid
+     * was asked for again.**
+     *
+     * smelt ships no expansion-rate threshold, because a threshold is a policy claim it
+     * has no basis for and the right rate depends on how aggressive a budget the caller
+     * chose — and a library printing warnings into someone else's process is bad manners.
+     * This is not a threshold. At `uniqueRetrieved === elisionsStored` the elision
+     * achieved nothing and cost a round trip: an arithmetic fact, not a preference. What
+     * to do about it is the caller's call.
+     *
+     * `false` for an empty store — nothing was hidden, so nothing was defeated.
+     */
+    readonly allElisionsRetrieved: boolean;
+}
+/**
+ * Local, content-addressed storage for elided bytes. No network, no eviction in v1 —
+ * evicting is how "reversible" quietly becomes "reversible for a while".
+ */
+export interface ElisionStore {
+    /** Store content, returning its hash. Idempotent for identical content. */
+    put(content: string): string;
+    /** The stored content, or `undefined` if this store never held that hash. */
+    peek(hash: string): string | undefined;
+    /**
+     * The stored content, *counted* as a retrieval. This is what the model's tool calls.
+     * @throws {UnknownHashError} when the hash is unknown.
+     */
+    retrieve(hash: string): string;
+    has(hash: string): boolean;
+    /** A snapshot of the counters. See {@link RetrieveStats}. */
+    stats(): RetrieveStats;
+}
+/**
+ * The retrieval tool a consumer exposes to its model. Deliberately not an MCP or
+ * provider-specific shape — smelt does not know which SDK you use. The consumer adapts
+ * this into its own tool schema; the contract is `hash in, exact bytes out`.
+ */
+export interface RetrieveTool {
+    /** `'smelt_retrieve'`. Stable — consumers hard-code it in prompts. */
+    readonly name: string;
+    /** Prose the consumer can put straight into a tool description. */
+    readonly description: string;
+    /** JSON-Schema-shaped parameter description, for consumers that want one. */
+    readonly inputSchema: {
+        readonly type: 'object';
+        readonly properties: {
+            readonly hash: {
+                readonly type: 'string';
+            };
+        };
+        readonly required: readonly ['hash'];
+    };
+    /** @throws {UnknownHashError} when the hash is unknown. */
+    invoke(input: {
+        readonly hash: string;
+    }): string;
+}
+/** A candidate handed to a {@link RerankStage}: an opaque id plus the text to judge. */
+export interface RerankCandidate {
+    readonly id: string;
+    readonly text: string;
+}
+/** A reranked candidate, most relevant first. `score` is the stage's own scale. */
+export interface RerankedCandidate extends RerankCandidate {
+    readonly score: number;
+}
+/**
+ * Relevance reranking — a *seam*, not a feature.
+ *
+ * Hosted rerankers are good and smelt will never bundle one, because bundling would
+ * break Law 1: the moment smelt ships a default reranker, `smelt()` can make a network
+ * call that the caller did not ask for and cannot see. A consumer that wants one
+ * implements this interface, wires its own key, and owns the fact that its context now
+ * leaves the machine. That decision must be legible in the consumer's own source.
+ */
+export interface RerankStage {
+    readonly id: string;
+    /** May make network calls — that is the consumer's choice, made in the consumer's code. */
+    rerank(candidates: readonly RerankCandidate[], query: string): Promise<readonly RerankedCandidate[]>;
+}
+/**
+ * Learned distillation — rewriting content with a model instead of cutting it.
+ *
+ * Out of v1 for a reason beyond the network: a distilled paragraph cannot satisfy
+ * Law 2. "The model summarised this" is not an explanation of what was removed, and
+ * the removed material is no longer recoverable from the output. If this ever ships,
+ * it ships as a stage that stores the original and explains itself in the same terms
+ * every other rule does.
+ */
+export interface DistillStage {
+    readonly id: string;
+    distill(text: string, budgetBytes: number): Promise<string>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

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

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@smeltjs/core",
+  "version": "0.1.0",
+  "description": "Structure-aware, reversible, offline context optimization for AI coding agents.",
+  "license": "Apache-2.0",
+  "author": "mong-x",
+  "homepage": "https://github.com/mong-x/smelt#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mong-x/smelt.git",
+    "directory": "packages/core"
+  },
+  "bugs": "https://github.com/mong-x/smelt/issues",
+  "keywords": [
+    "llm",
+    "context",
+    "tokens",
+    "tree-sitter",
+    "agents",
+    "compression",
+    "prompt-cache",
+    "offline"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "files": [
+    "dist",
+    "grammars",
+    "README.md",
+    "THIRD-PARTY.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "smelt": "dist/cli/bin.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node ../../scripts/bundle-grammars.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepack": "pnpm run build && node ../../scripts/generate-third-party.mjs",
+    "bench": "node bench/run.mjs"
+  },
+  "dependencies": {
+    "web-tree-sitter": "~0.25.10"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.0",
+    "tree-sitter-wasms": "^0.1.13",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.11"
+  }
+}