@wangzhizhi/remi 0.1.225 → 0.1.244

package/node_modules/@remi/config/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/config",
-  "version": "0.1.225",
+  "version": "0.1.244",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/core/dist/cacheBenchmark.js

@@ -0,0 +1,217 @@
+import { createHeuristicTokenEstimator } from '@remi/llm';
+import { buildProviderContext } from './contextBuilder.js';
+import { stableHash, stableStringify } from './stableHash.js';
+const defaultTokenEstimator = createHeuristicTokenEstimator();
+export function buildCacheShapeBenchmark(requests, options = {}) {
+    const tokenEstimator = options.tokenEstimator ?? defaultTokenEstimator;
+    const tokenEstimateProfile = options.tokenEstimateProfile ?? 'default';
+    const shapedRequests = requests.map(request => buildShapedRequest(request, tokenEstimator, tokenEstimateProfile));
+    const pairs = [];
+    for (let index = 1; index < shapedRequests.length; index += 1) {
+        const before = shapedRequests[index - 1];
+        const after = shapedRequests[index];
+        if (before && after) {
+            pairs.push(compareShapedRequests(before, after));
+        }
+    }
+    return {
+        requestCount: shapedRequests.length,
+        requests: shapedRequests.map(request => request.summary),
+        pairs,
+    };
+}
+export function buildRemiCacheShapeBenchmarkFixture() {
+    return buildCacheShapeBenchmark([
+        buildRemiCacheShapeBenchmarkRequest({
+            label: 'turn-1',
+            runtimePrompt: 'cwd=/Users/example/project\nlanguage=zh-Hans\nturn=1',
+            currentUserMessage: '优化缓存命中率',
+        }),
+        buildRemiCacheShapeBenchmarkRequest({
+            label: 'turn-2',
+            runtimePrompt: 'cwd=/Users/example/project\nlanguage=zh-Hans\nturn=2',
+            currentUserMessage: '继续验证 benchmark',
+        }),
+    ]);
+}
+export function buildRemiCacheShapeBenchmarkRequest(options) {
+    const context = buildProviderContext({
+        systemPrompt: 'Remi stable core behavior.',
+        toolPrompt: 'Remi stable tool-use policy.',
+        projectInstructions: 'Follow PLAN.md and update checklist after each step.',
+        projectInstructionsSource: 'AGENTS.md + PLAN.md',
+        memories: [
+            {
+                id: 'cache-memory',
+                type: 'project',
+                scope: 'project',
+                description: 'Cache optimization memory',
+                createdAt: '2026-06-04T00:00:00.000Z',
+                updatedAt: '2026-06-04T00:00:00.000Z',
+                useCount: 1,
+                body: 'Keep stable context layers before dynamic runtime facts.',
+                reason: 'benchmark fixture',
+            },
+        ],
+        sessionMemorySummary: 'Stable session memory summary for cache benchmark.',
+        compactSummary: 'Stable compact summary for cache benchmark.',
+        recentMessages: [
+            { role: 'user', content: '上一轮请求' },
+            { role: 'assistant', content: '上一轮已完成观测。' },
+        ],
+        runtimePrompt: options.runtimePrompt,
+        currentTurnPrompt: 'Current turn reminder stays near the active user message.',
+        currentUserMessage: options.currentUserMessage,
+    });
+    return {
+        label: options.label,
+        messages: context.messages,
+        trace: context.trace,
+        toolDefinitions: options.toolDefinitions ?? benchmarkToolDefinitions,
+    };
+}
+function buildShapedRequest(request, tokenEstimator, tokenEstimateProfile) {
+    const toolSchema = stableStringify(canonicalToolDefinitions(request.toolDefinitions));
+    const toolSchemaUnit = unitForText('tool-schema', toolSchema, tokenEstimator, tokenEstimateProfile);
+    const layerIds = messageLayerIds(request.trace);
+    const messageUnits = request.messages.map((message, index) => {
+        const serialized = stableStringify({ role: message.role, content: message.content });
+        return unitForText('message', serialized, tokenEstimator, tokenEstimateProfile, layerIds[index]);
+    });
+    const units = [toolSchemaUnit, ...messageUnits];
+    return {
+        request,
+        units,
+        summary: {
+            label: request.label,
+            messageCount: request.messages.length,
+            toolCount: request.toolDefinitions.length,
+            toolSchemaHash: toolSchemaUnit.hash,
+            toolSchemaTokens: toolSchemaUnit.tokenCount,
+            layerOrder: request.trace.layers.map(layer => layer.id),
+            currentUserMessageLast: request.messages.at(-1)?.role === 'user',
+            totalBytes: units.reduce((sum, unit) => sum + unit.byteCount, 0),
+            totalTokens: units.reduce((sum, unit) => sum + unit.tokenCount, 0),
+        },
+    };
+}
+function compareShapedRequests(before, after) {
+    let sharedUnitCount = 0;
+    let sharedByteCount = 0;
+    let sharedTokenCount = 0;
+    const sharedLayerIds = [];
+    const maxSharedUnits = Math.min(before.units.length, after.units.length);
+    for (let index = 0; index < maxSharedUnits; index += 1) {
+        const beforeUnit = before.units[index];
+        const afterUnit = after.units[index];
+        if (!beforeUnit || !afterUnit || beforeUnit.kind !== afterUnit.kind || beforeUnit.layerId !== afterUnit.layerId || beforeUnit.hash !== afterUnit.hash) {
+            break;
+        }
+        sharedUnitCount += 1;
+        sharedByteCount += afterUnit.byteCount;
+        sharedTokenCount += afterUnit.tokenCount;
+        if (afterUnit.layerId && !sharedLayerIds.includes(afterUnit.layerId)) {
+            sharedLayerIds.push(afterUnit.layerId);
+        }
+    }
+    const firstChanged = after.units[sharedUnitCount];
+    const firstChangedLayer = firstChanged?.layerId ? layerIndexAndId(after.request.trace, firstChanged.layerId) : undefined;
+    const changedLayers = changedLayerReports(before.request.trace, after.request.trace);
+    const stableLayers = after.request.trace.layers
+        .filter(layer => layer.included && !changedLayers.some(changed => changed.id === layer.id))
+        .map(layer => ({
+        id: layer.id,
+        tokenCount: layer.tokenCount,
+        ...(layer.hash ? { hash: layer.hash } : {}),
+    }));
+    return {
+        from: before.request.label,
+        to: after.request.label,
+        toolSchemaChanged: before.summary.toolSchemaHash !== after.summary.toolSchemaHash,
+        toolSchemaHashBefore: before.summary.toolSchemaHash,
+        toolSchemaHashAfter: after.summary.toolSchemaHash,
+        toolSchemaTokensBefore: before.summary.toolSchemaTokens,
+        toolSchemaTokensAfter: after.summary.toolSchemaTokens,
+        firstChangedUnit: firstChanged ? firstChanged.kind : 'none',
+        ...(firstChanged && firstChanged.kind === 'message' ? { firstChangedMessageIndex: sharedUnitCount - 1 } : {}),
+        ...(firstChangedLayer ? { firstChangedLayerIndex: firstChangedLayer.index, firstChangedLayerId: firstChangedLayer.id } : {}),
+        sharedPrefix: {
+            unitCount: sharedUnitCount,
+            byteCount: sharedByteCount,
+            tokenCount: sharedTokenCount,
+            percentOfNextBytes: after.summary.totalBytes > 0 ? sharedByteCount / after.summary.totalBytes : 0,
+            layerIds: sharedLayerIds,
+        },
+        stableLayers,
+        changedLayers,
+    };
+}
+function canonicalToolDefinitions(tools) {
+    return [...tools]
+        .map(tool => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters,
+    }))
+        .sort((left, right) => left.name.localeCompare(right.name) || left.description.localeCompare(right.description));
+}
+function messageLayerIds(trace) {
+    return trace.layers.flatMap(layer => Array.from({ length: layer.messageCount }, () => layer.id));
+}
+function unitForText(kind, text, tokenEstimator, tokenEstimateProfile, layerId) {
+    return {
+        kind,
+        hash: stableHash(text),
+        byteCount: Buffer.byteLength(text, 'utf8'),
+        tokenCount: tokenEstimator.estimateText({ text, profile: tokenEstimateProfile }).tokens,
+        ...(layerId ? { layerId } : {}),
+    };
+}
+function layerIndexAndId(trace, layerId) {
+    const index = trace.layers.findIndex(layer => layer.id === layerId);
+    return index >= 0 ? { index, id: layerId } : undefined;
+}
+function changedLayerReports(before, after) {
+    const beforeById = new Map(before.layers.map(layer => [layer.id, layer]));
+    return after.layers
+        .filter(layer => {
+        const previous = beforeById.get(layer.id);
+        return !previous || previous.included !== layer.included || previous.hash !== layer.hash;
+    })
+        .map(layer => {
+        const previous = beforeById.get(layer.id);
+        return {
+            id: layer.id,
+            ...(previous?.hash ? { beforeHash: previous.hash } : {}),
+            ...(layer.hash ? { afterHash: layer.hash } : {}),
+            includedBefore: previous?.included ?? false,
+            includedAfter: layer.included,
+        };
+    });
+}
+const benchmarkToolDefinitions = [
+    {
+        name: 'read_file',
+        description: 'Read a local file.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string' },
+            },
+            required: ['path'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'search_text',
+        description: 'Search text in local files.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: { type: 'string' },
+            },
+            required: ['query'],
+            additionalProperties: false,
+        },
+    },
+];

package/node_modules/@remi/core/dist/cacheDiagnostics.js

@@ -0,0 +1,300 @@
+import { stableHash, stableStringify } from './stableHash.js';
+export function latestCacheDiagnostic(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event?.type === 'cache_diagnostic') {
+            return event;
+        }
+    }
+    return undefined;
+}
+export function buildCacheDiagnosticReport(events) {
+    const diagnostics = events.filter((event) => event.type === 'cache_diagnostic');
+    if (diagnostics.length === 0) {
+        return emptyCacheDiagnosticReport();
+    }
+    const missReasons = new Map();
+    const changedLayers = new Map();
+    let inputTokens = 0;
+    let cachedInputTokens = 0;
+    let outputTokens = 0;
+    let totalTokens = 0;
+    let toolSchemaChanges = 0;
+    let prefixChanges = 0;
+    for (const diagnostic of diagnostics) {
+        inputTokens += diagnostic.usage.inputTokens;
+        cachedInputTokens += diagnostic.usage.cachedInputTokens;
+        outputTokens += diagnostic.usage.outputTokens;
+        totalTokens += diagnostic.usage.totalTokens;
+        missReasons.set(diagnostic.inference.missReason, (missReasons.get(diagnostic.inference.missReason) ?? 0) + 1);
+        if (diagnostic.inference.toolSchemaChanged) {
+            toolSchemaChanges += 1;
+        }
+        if (diagnostic.inference.prefixChanged) {
+            prefixChanges += 1;
+        }
+        for (const layer of diagnostic.inference.changedLayers) {
+            changedLayers.set(layer, (changedLayers.get(layer) ?? 0) + 1);
+        }
+    }
+    const latest = diagnostics.at(-1);
+    const totalInputTokens = inputTokens + cachedInputTokens;
+    return {
+        diagnosticCount: diagnostics.length,
+        inputTokens,
+        cachedInputTokens,
+        outputTokens,
+        totalTokens,
+        totalInputTokens,
+        cacheHitRate: totalInputTokens > 0 ? cachedInputTokens / totalInputTokens : 0,
+        missReasons: reasonCountEntries(missReasons),
+        changedLayers: idCountEntries(changedLayers),
+        toolSchemaChanges,
+        prefixChanges,
+        ...(latest
+            ? {
+                latest: {
+                    turn: latest.request.turn,
+                    model: latest.model.displayName ?? latest.model.alias,
+                    missReason: latest.inference.missReason,
+                    changedLayers: latest.inference.changedLayers,
+                    toolSchemaChanged: latest.inference.toolSchemaChanged,
+                    prefixChanged: latest.inference.prefixChanged,
+                    prefixHash: latest.request.prefixHash,
+                    toolSchemaHash: latest.request.toolSchemaHash,
+                    toolSchemaTokens: latest.request.toolSchemaTokens,
+                    toolCount: latest.request.toolCount,
+                    toolNames: latest.request.toolNames,
+                    cacheHitRate: latest.usage.cacheHitRate,
+                },
+            }
+            : {}),
+    };
+}
+export function formatCacheDiagnosticStatus(report, language = 'en') {
+    if (report.diagnosticCount === 0 || !report.latest) {
+        return language === 'zh-Hans' ? '暂无诊断' : 'no diagnostics yet';
+    }
+    const latest = report.latest;
+    const parts = language === 'zh-Hans'
+        ? [
+            `命中 ${formatPercent(report.cacheHitRate)}`,
+            `cached ${formatTokenCount(report.cachedInputTokens)} / input ${formatTokenCount(report.totalInputTokens)}`,
+            `最近 ${formatMissReason(latest.missReason, language)}`,
+        ]
+        : [
+            `${formatPercent(report.cacheHitRate)} hit`,
+            `cached ${formatTokenCount(report.cachedInputTokens)} / input ${formatTokenCount(report.totalInputTokens)}`,
+            `last ${formatMissReason(latest.missReason, language)}`,
+        ];
+    if (latest.changedLayers.length > 0) {
+        parts.push(language === 'zh-Hans' ? `层 ${latest.changedLayers.join(',')}` : `changed ${latest.changedLayers.join(',')}`);
+    }
+    if (latest.toolSchemaChanged) {
+        parts.push(language === 'zh-Hans' ? '工具 schema 变更' : 'tools changed');
+    }
+    if (latest.prefixChanged) {
+        parts.push(language === 'zh-Hans' ? 'prefix 变更' : 'prefix changed');
+    }
+    return parts.join(' · ');
+}
+export function buildCacheDiagnostic(options) {
+    const canonicalTools = canonicalToolDefinitions(options.toolDefinitions);
+    const toolSchemaText = stableStringify(canonicalTools);
+    const toolSchemaHash = stableHash(canonicalTools);
+    const messageShape = options.messages.map(cacheMessageShape);
+    const messageHash = stableHash(messageShape);
+    const prefixHash = stableHash({ messages: messageShape, tools: canonicalTools });
+    const cachedInputTokens = options.usage.cachedInputTokens ?? 0;
+    const inputTokens = options.usage.inputTokens;
+    const inputDenominator = inputTokens + cachedInputTokens;
+    const toolNames = canonicalTools.map(tool => tool.name);
+    const layers = options.contextTrace.layers.map(layer => ({
+        id: layer.id,
+        included: layer.included,
+        ...(layer.hash ? { hash: layer.hash } : {}),
+        tokenCount: layer.tokenCount,
+        messageCount: layer.messageCount,
+    }));
+    const changedLayers = changedLayerIds(options.previous, layers);
+    const toolSchemaChanged = options.previous ? options.previous.request.toolSchemaHash !== toolSchemaHash : false;
+    const prefixChanged = options.previous ? options.previous.request.prefixHash !== prefixHash : false;
+    return {
+        type: 'cache_diagnostic',
+        model: {
+            profile: options.model.profile,
+            role: options.model.role,
+            alias: options.model.alias,
+            displayName: options.model.displayName,
+            provider: options.model.providerAlias,
+            model: options.model.model,
+            ...(options.model.effort ? { effort: options.model.effort } : {}),
+        },
+        request: {
+            turn: options.turn,
+            messageCount: options.messages.length,
+            prefixHash,
+            messageHash,
+            toolSchemaHash,
+            toolSchemaTokens: options.tokenEstimator.estimateText({ text: toolSchemaText, profile: options.tokenEstimateProfile }).tokens,
+            toolCount: canonicalTools.length,
+            toolNames,
+        },
+        layers,
+        usage: {
+            inputTokens,
+            cachedInputTokens,
+            outputTokens: options.usage.outputTokens,
+            totalTokens: Math.max(options.usage.totalTokens, inputTokens + cachedInputTokens + options.usage.outputTokens),
+            cacheHitRate: inputDenominator > 0 ? cachedInputTokens / inputDenominator : 0,
+        },
+        inference: {
+            inferred: true,
+            missReason: inferMissReason({
+                missTokens: inputTokens,
+                ...(options.previous ? { previous: options.previous } : {}),
+                changedLayers,
+                toolSchemaChanged,
+                prefixChanged,
+            }),
+            changedLayers,
+            toolSchemaChanged,
+            prefixChanged,
+        },
+    };
+}
+function canonicalToolDefinitions(tools) {
+    return [...tools]
+        .map(tool => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters,
+    }))
+        .sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
+}
+function cacheMessageShape(message) {
+    if (message.role === 'tool') {
+        return {
+            role: 'tool',
+            toolCallId: message.toolCallId,
+            contentHash: stableHash(message.content),
+        };
+    }
+    if (message.role === 'assistant' && message.toolCalls && message.toolCalls.length > 0) {
+        return {
+            role: 'assistant',
+            contentHash: stableHash(message.content),
+            ...(message.reasoningContent ? { reasoningHash: stableHash(message.reasoningContent) } : {}),
+            toolCallsHash: stableHash(message.toolCalls),
+        };
+    }
+    return {
+        role: message.role,
+        contentHash: stableHash(message.content),
+    };
+}
+function changedLayerIds(previous, currentLayers) {
+    if (!previous) {
+        return [];
+    }
+    const previousById = new Map(previous.layers.map(layer => [layer.id, layer]));
+    return currentLayers
+        .filter(layer => {
+        const before = previousById.get(layer.id);
+        return !before || before.hash !== layer.hash || before.included !== layer.included;
+    })
+        .map(layer => layer.id);
+}
+function inferMissReason(options) {
+    if (options.missTokens <= 0) {
+        return 'no-miss';
+    }
+    if (!options.previous) {
+        return 'cold-start';
+    }
+    if (options.toolSchemaChanged) {
+        return 'tool-schema-changed';
+    }
+    if (options.changedLayers.length > 0) {
+        return 'layer-changed';
+    }
+    if (!options.prefixChanged) {
+        return 'prefix-stable-provider-side';
+    }
+    return 'unknown';
+}
+function emptyCacheDiagnosticReport() {
+    return {
+        diagnosticCount: 0,
+        inputTokens: 0,
+        cachedInputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        totalInputTokens: 0,
+        cacheHitRate: 0,
+        missReasons: [],
+        changedLayers: [],
+        toolSchemaChanges: 0,
+        prefixChanges: 0,
+    };
+}
+function reasonCountEntries(counts) {
+    const orderByValue = new Map(reasonOrder.map((value, index) => [value, index]));
+    const entries = [...counts.entries()].sort(([leftId, leftCount], [rightId, rightCount]) => {
+        if (leftCount !== rightCount) {
+            return rightCount - leftCount;
+        }
+        const leftOrder = orderByValue.get(leftId) ?? Number.MAX_SAFE_INTEGER;
+        const rightOrder = orderByValue.get(rightId) ?? Number.MAX_SAFE_INTEGER;
+        if (leftOrder !== rightOrder) {
+            return leftOrder - rightOrder;
+        }
+        return leftId < rightId ? -1 : leftId > rightId ? 1 : 0;
+    });
+    return entries.map(([reason, count]) => ({ reason, count }));
+}
+function idCountEntries(counts) {
+    const entries = [...counts.entries()].sort(([leftId, leftCount], [rightId, rightCount]) => {
+        if (leftCount !== rightCount) {
+            return rightCount - leftCount;
+        }
+        return leftId < rightId ? -1 : leftId > rightId ? 1 : 0;
+    });
+    return entries.map(([id, count]) => ({ id, count }));
+}
+const reasonOrder = [
+    'no-miss',
+    'cold-start',
+    'tool-schema-changed',
+    'layer-changed',
+    'prefix-stable-provider-side',
+    'unknown',
+];
+function formatMissReason(reason, language) {
+    const labels = {
+        'no-miss': { en: 'no miss', 'zh-Hans': '无 miss' },
+        'cold-start': { en: 'cold start', 'zh-Hans': '冷启动' },
+        'tool-schema-changed': { en: 'tool schema changed', 'zh-Hans': '工具 schema 变化' },
+        'layer-changed': { en: 'layer changed', 'zh-Hans': '上下文层变化' },
+        'prefix-stable-provider-side': { en: 'provider-side miss', 'zh-Hans': 'prefix 稳定但 provider miss' },
+        unknown: { en: 'unknown', 'zh-Hans': '未知' },
+    };
+    return labels[reason][language];
+}
+function formatPercent(value) {
+    const percent = value * 100;
+    const precision = percent >= 99 && percent < 100 ? 1 : 0;
+    return `${percent.toFixed(precision).replace(/\.0$/, '')}%`;
+}
+function formatTokenCount(value) {
+    if (value >= 1_000_000) {
+        return `${trimFixed(value / 1_000_000)}m`;
+    }
+    if (value >= 1_000) {
+        return `${trimFixed(value / 1_000)}k`;
+    }
+    return String(value);
+}
+function trimFixed(value) {
+    return value.toFixed(value >= 10 ? 0 : 1).replace(/\.0$/, '');
+}

package/node_modules/@remi/core/dist/contextBuilder.js

@@ -1,4 +1,5 @@
 import { createHeuristicTokenEstimator } from '@remi/llm';
+import { stableHash } from './stableHash.js';
 const defaultTokenEstimator = createHeuristicTokenEstimator();
 // Global "收口": per-layer budgets are allocated with floors, so for a small
 // effective input budget their sum can exceed the budget. Shrink low-priority
@@ -221,6 +222,17 @@ export function buildProviderContext(options) {
             tokenCount: 0,
         }, charBudgets.compact, tokenBudgets.compact);
     }
+    addMessageLayer({
+        id: 'recent',
+        source: '~/.remi sessions recent user/assistant transcript',
+        messages,
+        layers,
+        layerMessages: applyMessagesBudget(options.recentMessages ?? [], charBudgets.recent, tokenBudgets.recent, tokenEstimator, tokenEstimateProfile),
+        budgetChars: charBudgets.recent,
+        budgetTokens: tokenBudgets.recent,
+        tokenEstimator,
+        tokenEstimateProfile,
+    });
     if (options.runtimePrompt && options.runtimePrompt.trim().length > 0) {
         addMessageLayer({
             id: 'runtime',
@@ -249,17 +261,6 @@ export function buildProviderContext(options) {
             tokenCount: 0,
         }, charBudgets.runtime, tokenBudgets.runtime);
     }
-    addMessageLayer({
-        id: 'recent',
-        source: '~/.remi sessions recent user/assistant transcript',
-        messages,
-        layers,
-        layerMessages: applyMessagesBudget(options.recentMessages ?? [], charBudgets.recent, tokenBudgets.recent, tokenEstimator, tokenEstimateProfile),
-        budgetChars: charBudgets.recent,
-        budgetTokens: tokenBudgets.recent,
-        tokenEstimator,
-        tokenEstimateProfile,
-    });
     const currentLayerMessages = [];
     if (options.currentTurnPrompt && options.currentTurnPrompt.trim().length > 0) {
         currentLayerMessages.push({
@@ -323,6 +324,7 @@ function addMessageLayer(options) {
         messageCount: options.layerMessages.length,
         charCount: content.length,
         tokenCount: estimateTextTokens(content, options.tokenEstimator, options.tokenEstimateProfile),
+        ...(included ? { hash: stableHash(layerMessages.map(message => ({ role: message.role, content: message.content }))) } : {}),
     }, options.budgetChars, options.budgetTokens);
 }
 function addTrace(layers, trace, budgetChars, budgetTokens) {