@trazum/core 1.8.0

package/dist/shared-prefix.js

@@ -0,0 +1,151 @@
+import { normalizeForCompare } from './similarity.js';
+import { estimateTokens } from './tokenizer.js';
+/**
+ * The waste no single prompt can see.
+ *
+ * Every other analysis in this package reads one prompt. This one reads a
+ * workspace, because there is a kind of caching loss that only exists *between*
+ * prompts: forty prompts assembled from the same system preamble, byte-identical
+ * except that one has a trailing space, another reordered two bullets, and a
+ * third says "You are an assistant" where the rest say "You are an Assistant".
+ *
+ * Prompt caching is a byte-for-byte prefix match. Those forty prompts therefore
+ * occupy forty separate cache entries and share nothing. Unify the preamble and
+ * they occupy one. No amount of analysis of any one of those files can find that
+ * — each is individually fine — which is what makes this worth a module rather
+ * than another advisory.
+ *
+ * **It reports no dollar figure, and that is a finding rather than a gap.**
+ *
+ * The saving lives entirely in the cache hit rate: a prompt called ten times a
+ * month never warms an entry of its own and always reads a shared one that
+ * somebody else keeps hot. But `cacheHitRate` is an *input* to Trazum's cost
+ * model, not an output — `advisories.ts` takes it from `--cache-hit-rate` and
+ * applies the same value to every prompt. Under that model, splitting one prefix
+ * into forty changes nothing, because the model has no term for how many distinct
+ * cache entries exist.
+ *
+ * Pricing this would mean inventing a distribution of calls across the group,
+ * which is the one thing here that only the operator knows. So the report gives
+ * what it can establish — which prompts, how far the common prefix runs, and what
+ * stops it being byte-identical — and refuses the number. Naming a mechanism
+ * accurately beats attaching a figure to it that came from nowhere.
+ */
+/** Blocks are blank-line separated, the same unit `reorder.ts` moves. */
+function blocksOf(text) {
+    return text.split(/\n[ \t]*\n/);
+}
+/**
+ * Whitespace collapsed, and nothing else touched.
+ *
+ * Used to separate the two kinds of drift, because they are different amounts of
+ * work to fix. A prefix that differs only here is a formatter away from sharing a
+ * cache entry; one that differs in wording needs somebody to decide which wording
+ * is right.
+ */
+function collapseWhitespace(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+/**
+ * The prefix length below which unifying buys nothing, and `Infinity` when there
+ * is no answer.
+ *
+ * Lives here rather than in the CLI because it is the gate on this whole report
+ * and a gate with no test is decoration. It was a private function in the CLI
+ * first; a mutation run deleting the `unknown` branch survived, which is what a
+ * function nothing can reach looks like from the outside.
+ *
+ * `unknown` and a missing minimum both yield `Infinity`, so nothing is reported.
+ * That is the direction to fail: telling somebody to unify a preamble across
+ * twelve files to enable caching their provider may not offer spends their
+ * afternoon, and unlike a wrong number on a report nothing later corrects it.
+ */
+export function cacheableMinimum(model) {
+    if (!model)
+        return Number.POSITIVE_INFINITY;
+    if (model.caching === 'none' || model.caching === 'unknown')
+        return Number.POSITIVE_INFINITY;
+    return model.cacheMinTokens ?? Number.POSITIVE_INFINITY;
+}
+/**
+ * Groups of prompts that could share a cache prefix and do not.
+ *
+ * Grouped by their **first** block, which is not a shortcut. Caching matches from
+ * the beginning of the request, so two prompts whose opening paragraphs differ
+ * share nothing no matter how identical the rest is — a group keyed on anything
+ * later would name prompts that cannot be made to share a prefix without
+ * reordering them, which is a different and far more dangerous change.
+ */
+export function sharedPrefixes(prompts, options = {}) {
+    const counter = options.countTokens ?? estimateTokens;
+    const minTokens = options.minTokens ?? 0;
+    const byOpening = new Map();
+    for (const prompt of prompts) {
+        const blocks = blocksOf(prompt.text);
+        const opening = normalizeForCompare(blocks[0] ?? '');
+        // An empty opening is not a match, it is an absence. Grouping on it would
+        // put every blank-led prompt in one group and report a prefix of nothing.
+        if (opening === '')
+            continue;
+        const group = byOpening.get(opening);
+        if (group)
+            group.push(prompt);
+        else
+            byOpening.set(opening, [prompt]);
+    }
+    const found = [];
+    for (const group of byOpening.values()) {
+        if (group.length < 2)
+            continue;
+        const blockLists = group.map((prompt) => blocksOf(prompt.text));
+        const first = blockLists[0];
+        if (!first)
+            continue;
+        // How far the agreement runs, comparing normalised blocks position by
+        // position. Stops at the first block any member disagrees on, because a
+        // prefix is contiguous by definition.
+        let shared = 0;
+        for (let index = 0; index < first.length; index++) {
+            const target = normalizeForCompare(first[index] ?? '');
+            if (target === '')
+                break;
+            const all = blockLists.every((blocks) => normalizeForCompare(blocks[index] ?? '') === target);
+            if (!all)
+                break;
+            shared = index + 1;
+        }
+        if (shared === 0)
+            continue;
+        /**
+         * The raw prefixes, joined the way they were written.
+         *
+         * `\n\n` rather than the original separator: the separator is itself part of
+         * what may differ, and reconstructing each prompt's exact bytes is not needed
+         * to answer whether they agree.
+         */
+        const rawPrefixes = blockLists.map((blocks) => blocks.slice(0, shared).join('\n\n'));
+        const sample = rawPrefixes[0] ?? '';
+        // Already byte-identical: these prompts share a cache entry today and there
+        // is nothing to recover. Reporting them would be noise that teaches people
+        // to stop reading this section.
+        if (rawPrefixes.every((prefix) => prefix === sample))
+            continue;
+        const collapsed = rawPrefixes.map(collapseWhitespace);
+        const flat = collapseWhitespace(sample);
+        const drift = collapsed.every((prefix) => prefix === flat) ? 'whitespace' : 'wording';
+        const tokens = counter(sample);
+        if (tokens < minTokens)
+            continue;
+        found.push({
+            paths: group.map((prompt) => prompt.path),
+            blocks: shared,
+            tokens,
+            drift,
+            sample,
+        });
+    }
+    // Largest prefix first: it is the group where unifying recovers most, and the
+    // ordering is a total one so the output does not depend on Map iteration.
+    return found.sort((a, b) => b.tokens - a.tokens || (a.paths[0] ?? '').localeCompare(b.paths[0] ?? ''));
+}
+//# sourceMappingURL=shared-prefix.js.map

package/dist/shared-prefix.js.map

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

package/dist/similarity.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Text-similarity helpers shared by the duplicate rules and the structural
+ * analysis.
+ *
+ * Both need to answer "are these two chunks saying the same thing?", and both
+ * need to answer it the same way — a rule that removes a near-duplicate and an
+ * advisory that reports one should never disagree about what "near" means.
+ */
+/** Normalises a line or paragraph for duplicate comparison. */
+export declare function normalizeForCompare(text: string): string;
+/** Jaccard similarity over word sets. */
+export declare function jaccard(a: string, b: string): number;
+//# sourceMappingURL=similarity.d.ts.map

package/dist/similarity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"similarity.d.ts","sourceRoot":"","sources":["../src/similarity.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,+DAA+D;AAC/D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOxD;AAED,yCAAyC;AACzC,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAOpD"}

package/dist/similarity.js

@@ -0,0 +1,30 @@
+/**
+ * Text-similarity helpers shared by the duplicate rules and the structural
+ * analysis.
+ *
+ * Both need to answer "are these two chunks saying the same thing?", and both
+ * need to answer it the same way — a rule that removes a near-duplicate and an
+ * advisory that reports one should never disagree about what "near" means.
+ */
+/** Normalises a line or paragraph for duplicate comparison. */
+export function normalizeForCompare(text) {
+    return text
+        .toLowerCase()
+        .normalize('NFD')
+        .replace(/\p{Diacritic}/gu, '')
+        .replace(/[^\p{L}\p{N}]+/gu, ' ')
+        .trim();
+}
+/** Jaccard similarity over word sets. */
+export function jaccard(a, b) {
+    const setA = new Set(a.split(' ').filter(Boolean));
+    const setB = new Set(b.split(' ').filter(Boolean));
+    if (setA.size === 0 || setB.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const word of setA)
+        if (setB.has(word))
+            intersection++;
+    return intersection / (setA.size + setB.size - intersection);
+}
+//# sourceMappingURL=similarity.js.map

package/dist/similarity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"similarity.js","sourceRoot":"","sources":["../src/similarity.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,+DAA+D;AAC/D,MAAM,UAAU,mBAAmB,CAAC,IAAY;IAC9C,OAAO,IAAI;SACR,WAAW,EAAE;SACb,SAAS,CAAC,KAAK,CAAC;SAChB,OAAO,CAAC,iBAAiB,EAAE,EAAE,CAAC;SAC9B,OAAO,CAAC,kBAAkB,EAAE,GAAG,CAAC;SAChC,IAAI,EAAE,CAAC;AACZ,CAAC;AAED,yCAAyC;AACzC,MAAM,UAAU,OAAO,CAAC,CAAS,EAAE,CAAS;IAC1C,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IACnD,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IACnD,IAAI,IAAI,CAAC,IAAI,KAAK,CAAC,IAAI,IAAI,CAAC,IAAI,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IACjD,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,KAAK,MAAM,IAAI,IAAI,IAAI;QAAE,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,YAAY,EAAE,CAAC;IAC5D,OAAO,YAAY,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC,CAAC;AAC/D,CAAC"}

package/dist/structure.d.ts

@@ -0,0 +1,144 @@
+import type { ContradictionAxisId, ContradictionValueId } from './i18n/types.js';
+import type { TokenCounter } from './types.js';
+/**
+ * Structural analysis.
+ *
+ * Every rule in `rules.ts` matches a phrase. The waste this module looks for
+ * is a relationship between two places in the prompt — an instruction that
+ * contradicts another, an example that teaches what an earlier one already
+ * taught. No dictionary can see either, because neither is wrong on its own.
+ *
+ * Everything here is advisory. A contradiction has a right answer only the
+ * author knows, and an example that looks redundant may be demonstrating a
+ * boundary case on purpose. Trazum points; it does not cut.
+ */
+/**
+ * Sourced from the i18n contract rather than declared here, so adding an axis
+ * fails to compile until every catalogue can name it.
+ */
+export type ContradictionAxis = ContradictionAxisId;
+export interface ContradictionSide {
+    /** Which end of the axis this instruction sits on. */
+    value: ContradictionValueId;
+    /** The sentence it was found in, trimmed for display. */
+    snippet: string;
+}
+export interface Contradiction {
+    axis: ContradictionAxis;
+    a: ContradictionSide;
+    b: ContradictionSide;
+}
+/**
+ * Finds instructions that pull in opposite directions on the same axis.
+ *
+ * Only the first occurrence of each value is kept, and an axis reports at most
+ * one contradiction: a prompt that says "be concise" four times and "be
+ * thorough" once has one problem, not four.
+ *
+ * Two matches inside the same sentence are ignored. "Be concise but complete"
+ * is a deliberate trade-off an author wrote on purpose; flagging it would
+ * train people to ignore the advisory.
+ */
+export declare function findContradictions(prompt: string): Contradiction[];
+/**
+ * A labelled field inside a few-shot example — `Input:`, `Output:`, `A:`…
+ *
+ * Exported because the duplicate-line rule needs it: two examples that share
+ * an output line are demonstrating that two different inputs map to the *same*
+ * answer, which is often the whole point of including both. Deduplicating
+ * those lines leaves an example with no output at all — worse than the
+ * repetition it removed.
+ */
+export declare const EXAMPLE_FIELD_LINE: RegExp;
+export interface ExampleBlock {
+    text: string;
+    tokens: number;
+}
+export interface RedundantExample {
+    /** Index of the earlier example that already teaches this. */
+    duplicateOf: number;
+    index: number;
+    similarity: number;
+    tokens: number;
+}
+export interface ExampleAnalysis {
+    examples: ExampleBlock[];
+    redundant: RedundantExample[];
+    /** Tokens held by examples that repeat an earlier one. */
+    redundantTokens: number;
+}
+/** Splits the prompt into labelled example blocks. */
+export declare function findExamples(prompt: string, count: TokenCounter): ExampleBlock[];
+/**
+ * Reports examples that repeat what an earlier example already demonstrates.
+ *
+ * Each example is compared against every earlier one, and blamed on the first
+ * match: in a run of three near-identical examples the second and third are
+ * both reported against the first, rather than chaining.
+ */
+export declare function analyzeExamples(prompt: string, count: TokenCounter): ExampleAnalysis;
+/**
+ * A prompt that shows its output schema in a code block, and then describes
+ * the same fields again in prose, is paying for the schema twice.
+ *
+ * The block is the version that survives: it is unambiguous, and the
+ * protection pass already guarantees Trazum will not touch it. The prose
+ * restatement is what can go — but only a human can tell a restatement from a
+ * clarification that happens to name the same fields, so this reports and does
+ * not cut.
+ */
+export interface RestatedFormat {
+    /** Top-level keys found in the fenced schema. */
+    keys: string[];
+    /** Those keys that are also named in the prose outside the block. */
+    restatedKeys: string[];
+    /** Tokens held by the prose sentences that restate them. */
+    restatedTokens: number;
+}
+/**
+ * Finds an output schema that the prose repeats.
+ *
+ * The threshold is deliberately blunt: naming one or two fields in prose is
+ * ordinary ("set `escalate` to true when the customer asks for a human"), and
+ * flagging that would make the advisory noise. Three or more, and the prose is
+ * walking the schema.
+ */
+export declare function findRestatedFormat(prompt: string, count: TokenCounter): RestatedFormat | null;
+/**
+ * A schema shown in the prompt that the request could carry as a parameter.
+ *
+ * Every provider worth naming now accepts a response schema alongside the
+ * message — `output_config.format`, `response_format`, `responseSchema`,
+ * whatever it is called this quarter. A prompt that spells the same shape out in
+ * a fenced block pays for it in input tokens on **every call**, and gets a
+ * weaker guarantee for the money: prose asks the model to comply, a parameter
+ * makes the decoder comply.
+ *
+ * So this is the rare finding that is not a trade-off. Moving a schema out is
+ * cheaper *and* stricter. What stops it being a rule is that Trazum cannot make
+ * the change: it edits prompts, and this is a change to the call around the
+ * prompt. It reports, names the tokens, and leaves the edit to whoever owns the
+ * client code.
+ *
+ * **The one way this could do harm, and what prevents it.** A fenced JSON block
+ * in a prompt is one of two completely different things. `Output format: {...}`
+ * is a contract and moving it is free. `Input: {...}` inside a few-shot example
+ * is *data the prompt needs*, and moving it breaks the prompt. Nothing here
+ * guesses which: a block counts only when a phrase from `OUTPUT_CUES_BY_LANGUAGE`
+ * appears in the text immediately before it. A schema with no such phrase is
+ * left alone, and a prompt in a language those dictionaries do not cover raises
+ * nothing at all — a false negative, stated as one, rather than an English cue
+ * matched inside Japanese prose and called a saving.
+ */
+export interface MovableSchema {
+    /** Fenced blocks that an output cue introduces. */
+    blocks: number;
+    /** Top-level keys across all of them, deduplicated. */
+    keys: string[];
+    /** Tokens the blocks hold, fences included, since all of it leaves the prompt. */
+    tokens: number;
+    /** The cue that identified the first block, so the report can quote it. */
+    cue: string;
+}
+export declare function findMovableSchema(prompt: string, count: TokenCounter): MovableSchema | null;
+//# sourceMappingURL=structure.d.ts.map

package/dist/structure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structure.d.ts","sourceRoot":"","sources":["../src/structure.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACjF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;;;;;;;;GAWG;AAMH;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,mBAAmB,CAAC;AAEpD,MAAM,WAAW,iBAAiB;IAChC,sDAAsD;IACtD,KAAK,EAAE,oBAAoB,CAAC;IAC5B,yDAAyD;IACzD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,iBAAiB,CAAC;IACxB,CAAC,EAAE,iBAAiB,CAAC;IACrB,CAAC,EAAE,iBAAiB,CAAC;CACtB;AAoID;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,EAAE,CA6BlE;AA6CD;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,QAG9B,CAAC;AAEF,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,8DAA8D;IAC9D,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,0DAA0D;IAC1D,eAAe,EAAE,MAAM,CAAC;CACzB;AAqED,sDAAsD;AACtD,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,YAAY,EAAE,CAWhF;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,eAAe,CAyBpF;AAMD;;;;;;;;;GASG;AACH,MAAM,WAAW,cAAc;IAC7B,iDAAiD;IACjD,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,qEAAqE;IACrE,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,4DAA4D;IAC5D,cAAc,EAAE,MAAM,CAAC;CACxB;AAmED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,cAAc,GAAG,IAAI,CAuC7F;AAUD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,aAAa;IAC5B,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAC;IACf,uDAAuD;IACvD,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,kFAAkF;IAClF,MAAM,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,GAAG,EAAE,MAAM,CAAC;CACb;AAqBD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,aAAa,GAAG,IAAI,CA4C3F"}