@wangzhizhi/remi 0.0.1-alpha

package/node_modules/@remi/compact/dist/index.js

@@ -0,0 +1,389 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { createSessionStore, readSessionEvents, sessionSummaryPath } from '@remi/sessions';
+export const compactPackageName = '@remi/compact';
+const defaultMaxSummaryChars = 6_000;
+const defaultMaxRecentItems = 6;
+const defaultMaxToolItems = 8;
+const defaultMaxSessionMemoryChars = 8_000;
+const defaultSessionMemoryMinimumTokensToInit = 10_000;
+const defaultSessionMemoryMinimumTokensBetweenUpdates = 5_000;
+const defaultSessionMemoryToolCallsBetweenUpdates = 3;
+export function estimateTextTokens(text) {
+    if (text.length === 0) {
+        return 0;
+    }
+    let asciiLike = 0;
+    let wideLike = 0;
+    for (const char of text) {
+        const code = char.codePointAt(0) ?? 0;
+        if ((code >= 0x3400 && code <= 0x9fff) ||
+            (code >= 0xf900 && code <= 0xfaff) ||
+            (code >= 0x3040 && code <= 0x30ff) ||
+            (code >= 0xac00 && code <= 0xd7af)) {
+            wideLike += 1;
+        }
+        else {
+            asciiLike += 1;
+        }
+    }
+    return Math.max(1, Math.ceil(asciiLike / 4 + wideLike * 0.8));
+}
+export function estimateSessionTokens(events) {
+    return estimateTextTokens(events.map(event => eventText(event)).filter(Boolean).join('\n'));
+}
+export function latestCompactSummary(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event?.type === 'compact' && event.summary.trim().length > 0) {
+            return event.summary;
+        }
+    }
+    return undefined;
+}
+export function eventsAfterLatestCompact(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        if (events[index]?.type === 'compact') {
+            return events.slice(index + 1);
+        }
+    }
+    return events;
+}
+export function readSessionMemory(cwd, sessionId) {
+    const path = sessionSummaryPath(cwd, sessionId);
+    if (!existsSync(path)) {
+        return undefined;
+    }
+    const parsed = parseSessionMemoryFile(readFileSync(path, 'utf8'), path);
+    if (!parsed || parsed.sessionId !== sessionId || parsed.content.trim().length === 0) {
+        return undefined;
+    }
+    return parsed;
+}
+export function buildSessionMemorySummary(events, options = {}) {
+    const maxSummaryChars = options.maxSummaryChars ?? defaultMaxSessionMemoryChars;
+    const maxRecentItems = options.maxRecentItems ?? defaultMaxRecentItems;
+    const maxToolItems = options.maxToolItems ?? defaultMaxToolItems;
+    const now = options.now ?? new Date().toISOString();
+    const estimatedTokens = estimateSessionTokens(events);
+    const users = events.filter((event) => event.type === 'user');
+    const assistants = events.filter((event) => event.type === 'assistant');
+    const systems = events.filter((event) => event.type === 'system');
+    const toolCalls = events.filter((event) => event.type === 'tool_call');
+    const toolResults = events.filter((event) => event.type === 'tool_result');
+    const latestUser = last(users);
+    const latestAssistant = last(assistants);
+    const fileHints = uniqueRecent([
+        ...toolCalls.flatMap(event => toolCallHints(event)),
+        ...toolResults.flatMap(event => toolResultHints(event)),
+    ], maxToolItems);
+    const failures = [
+        ...systems.filter(event => event.level === 'error' || event.level === 'warn').map(event => `${event.level}: ${oneLine(event.content, 260)}`),
+        ...toolResults.filter(event => !event.ok || event.errorCode).map(event => `${event.toolName}: ${event.errorCode ?? 'failed'} - ${oneLine(event.summary, 260)}`),
+    ].slice(-maxToolItems);
+    const recentToolResults = toolResults.slice(-maxToolItems).map(event => `- ${formatToolResult(event)}`);
+    const sections = [
+        '# Remi Session Memory',
+        '',
+        `Updated: ${now}`,
+        `Source events: ${events.length}`,
+        `Estimated source tokens: ${estimatedTokens}`,
+        '',
+        '## Current State',
+        `- Latest user objective: ${latestUser ? oneLine(latestUser.content, 320) : 'No user objective recorded yet.'}`,
+        `- Latest assistant result: ${latestAssistant ? oneLine(latestAssistant.content, 320) : 'No assistant result recorded yet.'}`,
+        '',
+        ...section('User Requests and Constraints', users.slice(-maxRecentItems).map(event => `- ${oneLine(event.content, 320)}`)),
+        ...section('Files Changed or Inspected', fileHints.map(hint => `- ${hint}`)),
+        ...section('Tool Results That Still Matter', recentToolResults),
+        ...section('Errors and Corrections', failures.map(issue => `- ${issue}`)),
+        ...section('Recent Decisions and Results', assistants.slice(-maxRecentItems).map(event => `- ${oneLine(event.content, 320)}`)),
+        '',
+        '## Pending Tasks and Next Step',
+        '- Continue from the latest user objective. Treat newer transcript messages after this summary as more authoritative.',
+    ];
+    const summary = truncateText(sections.join('\n'), maxSummaryChars);
+    return {
+        summary,
+        estimatedTokens,
+        sourceEventCount: events.length,
+    };
+}
+export function updateSessionMemory(cwd, sessionId, options = {}) {
+    const result = buildSessionMemorySummary(readSessionEvents(cwd, sessionId), options);
+    const now = options.now ?? new Date().toISOString();
+    const path = sessionSummaryPath(cwd, sessionId);
+    const summary = {
+        sessionId,
+        path,
+        content: result.summary,
+        updatedAt: now,
+        estimatedTokens: result.estimatedTokens,
+        sourceEventCount: result.sourceEventCount,
+    };
+    writeSessionMemoryFile(summary);
+    return summary;
+}
+export function maybeUpdateSessionMemory(cwd, sessionId, options = {}) {
+    const events = readSessionEvents(cwd, sessionId);
+    const previous = readSessionMemory(cwd, sessionId);
+    const decision = sessionMemoryUpdateReason(events, previous, options);
+    if (!decision.update) {
+        return previous ? { updated: false, reason: decision.reason, previous } : { updated: false, reason: decision.reason };
+    }
+    return {
+        updated: true,
+        reason: decision.reason,
+        summary: updateSessionMemory(cwd, sessionId, options),
+    };
+}
+export function buildCompactSummary(events, options = {}) {
+    const maxSummaryChars = options.maxSummaryChars ?? defaultMaxSummaryChars;
+    const maxRecentItems = options.maxRecentItems ?? defaultMaxRecentItems;
+    const maxToolItems = options.maxToolItems ?? defaultMaxToolItems;
+    const now = options.now ?? new Date().toISOString();
+    const priorSummary = latestCompactSummary(events);
+    const activeEvents = eventsAfterLatestCompact(events);
+    const sourceEvents = activeEvents.length > 0 ? activeEvents : events;
+    const estimatedTokens = estimateSessionTokens(sourceEvents);
+    const users = sourceEvents.filter((event) => event.type === 'user');
+    const assistants = sourceEvents.filter((event) => event.type === 'assistant');
+    const systems = sourceEvents.filter((event) => event.type === 'system');
+    const toolResults = sourceEvents.filter((event) => event.type === 'tool_result');
+    const latestUser = last(users);
+    const currentObjective = latestUser ? oneLine(latestUser.content, 240) : 'No current user objective found in this session segment.';
+    const openIssues = [
+        ...systems.filter(event => event.level === 'error' || event.level === 'warn').map(event => `${event.level}: ${oneLine(event.content, 220)}`),
+        ...toolResults.filter(event => !event.ok || event.errorCode).map(event => `${event.toolName}: ${event.errorCode ?? 'failed'} - ${oneLine(event.summary, 220)}`),
+    ].slice(-maxToolItems);
+    const sections = [
+        '# Remi Compact Summary',
+        '',
+        `Created: ${now}`,
+        `Source events since previous compact: ${sourceEvents.length}`,
+        `Estimated source tokens: ${estimatedTokens}`,
+        '',
+        '## Current Objective',
+        `- ${currentObjective}`,
+        '',
+        ...section('Prior Compact Summary', priorSummary ? [truncateText(priorSummary, 1_200)] : []),
+        ...section('Session Memory', options.sessionMemorySummary ? [truncateText(options.sessionMemorySummary, 1_800)] : []),
+        ...section('Recent User Requests', users.slice(-maxRecentItems).map(event => `- ${oneLine(event.content, 260)}`)),
+        ...section('Recent Assistant Results', assistants.slice(-maxRecentItems).map(event => `- ${oneLine(event.content, 260)}`)),
+        ...section('Tool Activity and Failures', toolResults.slice(-maxToolItems).map(event => `- ${formatToolResult(event)}`)),
+        ...section('Open Issues', openIssues.map(issue => `- ${issue}`)),
+        '',
+        '## Resume Guidance',
+        '- Use this summary as continuity context. Prefer newer user messages after this boundary when they conflict with older details.',
+    ];
+    const summary = truncateText(sections.join('\n'), maxSummaryChars);
+    return {
+        summary,
+        estimatedTokens,
+        sourceEventCount: sourceEvents.length,
+    };
+}
+export function compactSession(cwd, sessionId, options = {}) {
+    const sessionMemory = options.sessionMemorySummary ?? freshSessionMemoryForCompact(cwd, sessionId, options);
+    const result = buildCompactSummary(readSessionEvents(cwd, sessionId), {
+        ...options,
+        ...(sessionMemory ? { sessionMemorySummary: sessionMemory } : {}),
+    });
+    const trigger = options.trigger ?? 'manual';
+    const strategy = options.strategy ?? 'deterministic';
+    createSessionStore(cwd, sessionId).append({
+        type: 'compact',
+        summary: result.summary,
+        estimatedTokens: result.estimatedTokens,
+        sourceEventCount: result.sourceEventCount,
+        trigger,
+        strategy,
+    });
+    return {
+        ...result,
+        sessionId,
+        trigger,
+        strategy,
+    };
+}
+function freshSessionMemoryForCompact(cwd, sessionId, options) {
+    try {
+        return updateSessionMemory(cwd, sessionId, {
+            force: true,
+            ...(options.now !== undefined ? { now: options.now } : {}),
+            maxSummaryChars: Math.min(options.maxSummaryChars ?? defaultMaxSessionMemoryChars, defaultMaxSessionMemoryChars),
+            ...(options.maxRecentItems !== undefined ? { maxRecentItems: options.maxRecentItems } : {}),
+            ...(options.maxToolItems !== undefined ? { maxToolItems: options.maxToolItems } : {}),
+        }).content;
+    }
+    catch {
+        return readSessionMemory(cwd, sessionId)?.content;
+    }
+}
+function writeSessionMemoryFile(summary) {
+    mkdirSync(dirname(summary.path), { recursive: true });
+    const frontmatter = [
+        '---',
+        `sessionId: ${summary.sessionId}`,
+        `updatedAt: ${summary.updatedAt}`,
+        `sourceEventCount: ${summary.sourceEventCount}`,
+        `estimatedTokens: ${summary.estimatedTokens}`,
+        '---',
+        '',
+    ].join('\n');
+    writeFileSync(summary.path, `${frontmatter}${summary.content.trim()}\n`, { mode: 0o600 });
+}
+function parseSessionMemoryFile(content, path) {
+    const lines = content.split(/\r?\n/);
+    if (lines[0]?.trim() !== '---') {
+        return undefined;
+    }
+    const endIndex = lines.findIndex((line, index) => index > 0 && line.trim() === '---');
+    if (endIndex <= 0) {
+        return undefined;
+    }
+    const fields = parseSimpleFrontmatter(lines.slice(1, endIndex));
+    const sessionId = fields.get('sessionId');
+    const updatedAt = fields.get('updatedAt');
+    const sourceEventCount = Number.parseInt(fields.get('sourceEventCount') ?? '', 10);
+    const estimatedTokens = Number.parseInt(fields.get('estimatedTokens') ?? '', 10);
+    const body = lines.slice(endIndex + 1).join('\n').trim();
+    if (!sessionId || !updatedAt || !Number.isFinite(sourceEventCount) || !Number.isFinite(estimatedTokens)) {
+        return undefined;
+    }
+    return {
+        sessionId,
+        path,
+        content: body,
+        updatedAt,
+        sourceEventCount,
+        estimatedTokens,
+    };
+}
+function parseSimpleFrontmatter(lines) {
+    const fields = new Map();
+    for (const line of lines) {
+        const separatorIndex = line.indexOf(':');
+        if (separatorIndex <= 0) {
+            continue;
+        }
+        fields.set(line.slice(0, separatorIndex).trim(), line.slice(separatorIndex + 1).trim());
+    }
+    return fields;
+}
+function sessionMemoryUpdateReason(events, previous, options) {
+    if (options.force) {
+        return { update: true, reason: 'forced' };
+    }
+    if (events.length === 0) {
+        return { update: false, reason: 'empty session' };
+    }
+    if (last(events)?.type === 'tool_call') {
+        return { update: false, reason: 'tool call still pending' };
+    }
+    const estimatedTokens = estimateSessionTokens(events);
+    const minimumTokensToInit = options.minimumTokensToInit ?? defaultSessionMemoryMinimumTokensToInit;
+    if (!previous) {
+        if (estimatedTokens >= minimumTokensToInit) {
+            return { update: true, reason: `initial threshold met (${estimatedTokens} tokens)` };
+        }
+        return { update: false, reason: `below initial threshold (${estimatedTokens}/${minimumTokensToInit} tokens)` };
+    }
+    if (events.length <= previous.sourceEventCount) {
+        return { update: false, reason: 'no new events since previous summary' };
+    }
+    const minimumTokensBetweenUpdates = options.minimumTokensBetweenUpdates ?? defaultSessionMemoryMinimumTokensBetweenUpdates;
+    const tokensSincePrevious = estimatedTokens - previous.estimatedTokens;
+    if (tokensSincePrevious < minimumTokensBetweenUpdates) {
+        return { update: false, reason: `below update threshold (${tokensSincePrevious}/${minimumTokensBetweenUpdates} tokens)` };
+    }
+    const newEvents = events.slice(previous.sourceEventCount);
+    const toolEventsSincePrevious = newEvents.filter(event => event.type === 'tool_call' || event.type === 'tool_result').length;
+    const toolCallsBetweenUpdates = options.toolCallsBetweenUpdates ?? defaultSessionMemoryToolCallsBetweenUpdates;
+    const naturalBreak = last(events)?.type === 'assistant' || last(events)?.type === 'user';
+    if (toolEventsSincePrevious >= toolCallsBetweenUpdates || naturalBreak) {
+        return { update: true, reason: `update threshold met (${tokensSincePrevious} tokens, ${toolEventsSincePrevious} tool events)` };
+    }
+    return { update: false, reason: `waiting for tool activity or natural break (${toolEventsSincePrevious}/${toolCallsBetweenUpdates} tool events)` };
+}
+function section(title, lines) {
+    if (lines.length === 0) {
+        return [];
+    }
+    return ['', `## ${title}`, ...lines];
+}
+function last(items) {
+    return items.length > 0 ? items[items.length - 1] : undefined;
+}
+function eventText(event) {
+    if (event.type === 'user' || event.type === 'system' || event.type === 'assistant') {
+        return event.content;
+    }
+    if (event.type === 'tool_call') {
+        return `${event.toolName} ${JSON.stringify(event.input)}`;
+    }
+    if (event.type === 'tool_result') {
+        return `${event.toolName} ${event.summary}${artifactSuffix(event)}`;
+    }
+    if (event.type === 'compact') {
+        return event.summary;
+    }
+    return '';
+}
+function formatToolResult(event) {
+    return `${event.toolName}: ${event.ok ? 'ok' : 'failed'} - ${oneLine(event.summary, 260)}${artifactSuffix(event)}`;
+}
+function toolCallHints(event) {
+    const input = event.input;
+    return [
+        stringField(input, 'path'),
+        stringField(input, 'filePath'),
+        stringField(input, 'targetPath'),
+        stringField(input, 'cwd'),
+        stringField(input, 'command'),
+    ].filter((value) => Boolean(value)).map(value => `${event.toolName}: ${oneLine(value, 220)}`);
+}
+function toolResultHints(event) {
+    if (!/(read|list|search|glob|write|edit|delete|shell|command)/i.test(event.toolName)) {
+        return [];
+    }
+    return [`${event.toolName}: ${oneLine(event.summary, 240)}${artifactSuffix(event)}`];
+}
+function stringField(input, key) {
+    const value = input[key];
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+function uniqueRecent(values, limit) {
+    const selected = [];
+    const seen = new Set();
+    for (let index = values.length - 1; index >= 0; index -= 1) {
+        const value = values[index];
+        if (!value || seen.has(value)) {
+            continue;
+        }
+        selected.unshift(value);
+        seen.add(value);
+        if (selected.length >= limit) {
+            break;
+        }
+    }
+    return selected;
+}
+function artifactSuffix(event) {
+    if (!event.artifact) {
+        return '';
+    }
+    return ` (artifact: ${event.artifact.path}, ${event.artifact.bytes} bytes)`;
+}
+function oneLine(text, maxLength) {
+    return truncateText(text.replace(/\s+/g, ' ').trim(), maxLength);
+}
+function truncateText(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    if (maxLength <= 3) {
+        return text.slice(0, maxLength);
+    }
+    return `${text.slice(0, maxLength - 3)}...`;
+}

package/node_modules/@remi/compact/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@remi/compact",
+  "version": "0.0.1-alpha",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  }
+}