salmon-loop 0.2.3

package/dist/core/security/redaction.js

@@ -0,0 +1,160 @@
+const DEFAULT_REDACTION_MARK = '[REDACTED]';
+const DEFAULT_LIMITS = {
+    maxDepth: 6,
+};
+const DEFAULT_REDACTION_CONFIG = {
+    enabled: true,
+    mark: DEFAULT_REDACTION_MARK,
+    maxDepth: DEFAULT_LIMITS.maxDepth,
+};
+let currentConfig = { ...DEFAULT_REDACTION_CONFIG };
+let compiledPatterns = [];
+let redactionCount = 0;
+export function setRedactionConfig(options) {
+    if (!options) {
+        currentConfig = { ...DEFAULT_REDACTION_CONFIG };
+        compiledPatterns = [...SIMPLE_PATTERNS];
+        return currentConfig;
+    }
+    currentConfig = {
+        enabled: options.enabled ?? currentConfig.enabled,
+        mark: options.mark ?? currentConfig.mark,
+        maxDepth: options.maxDepth ?? currentConfig.maxDepth,
+        keyAllowlist: options.keyAllowlist ?? currentConfig.keyAllowlist,
+        keyDenylist: options.keyDenylist ?? currentConfig.keyDenylist,
+        patterns: options.patterns ?? currentConfig.patterns,
+        disableDefaults: options.disableDefaults ?? currentConfig.disableDefaults,
+    };
+    compiledPatterns = [];
+    if (!currentConfig.disableDefaults) {
+        compiledPatterns.push(...SIMPLE_PATTERNS);
+    }
+    if (currentConfig.patterns && currentConfig.patterns.length > 0) {
+        for (const pattern of currentConfig.patterns) {
+            try {
+                compiledPatterns.push(new RegExp(pattern, 'g'));
+            }
+            catch {
+                // Ignore invalid patterns to avoid breaking runtime.
+            }
+        }
+    }
+    return currentConfig;
+}
+export function getRedactionConfig() {
+    return { ...currentConfig };
+}
+export function redactByKey(key, value, options = {}) {
+    if (!key || !currentConfig.enabled) {
+        return { value, redacted: false };
+    }
+    const denylist = currentConfig.keyDenylist ?? [];
+    if (denylist.includes(key)) {
+        redactionCount += 1;
+        return { value: options.mark ?? currentConfig.mark, redacted: true };
+    }
+    const allowlist = currentConfig.keyAllowlist ?? [];
+    if (allowlist.length > 0 && !allowlist.includes(key)) {
+        return { value, redacted: false };
+    }
+    return { value, redacted: false };
+}
+export function drainRedactionMetrics() {
+    const count = redactionCount;
+    redactionCount = 0;
+    return { count };
+}
+const SIMPLE_PATTERNS = [
+    /sk-[A-Za-z0-9]{10,}/g,
+    /Bearer\s+[A-Za-z0-9._-]+\.[A-Za-z0-9._-]+\.[A-Za-z0-9._-]+/g,
+    /eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g,
+    /-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/g,
+    /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi,
+    /\b(?:\d{1,3}\.){3}\d{1,3}\b/g,
+];
+const KV_PATTERN = /(\b(?:token|secret|password|api[_-]?key)\b\s*[:=]\s*)([^\s,'"]+)/gi;
+const QUERY_PATTERN = /([?&](?:token|secret|password|api_key|apikey)=)([^&\s]+)/gi;
+compiledPatterns = [...SIMPLE_PATTERNS];
+export function redactSensitiveString(input, options = {}) {
+    if (!currentConfig.enabled) {
+        return { value: input, redacted: false };
+    }
+    const mark = options.mark ?? currentConfig.mark;
+    let output = input;
+    let redacted = false;
+    output = output.replace(KV_PATTERN, (_match, prefix, _value) => {
+        redacted = true;
+        return `${prefix}${mark}`;
+    });
+    output = output.replace(QUERY_PATTERN, (_match, prefix, _value) => {
+        redacted = true;
+        return `${prefix}${mark}`;
+    });
+    for (const pattern of compiledPatterns) {
+        const next = output.replace(pattern, mark);
+        if (next !== output) {
+            redacted = true;
+            output = next;
+        }
+        pattern.lastIndex = 0;
+    }
+    if (redacted) {
+        redactionCount += 1;
+    }
+    return { value: output, redacted };
+}
+export function redactSensitiveValue(value, options = {}, state = { depth: 0, seen: new WeakSet() }) {
+    if (!currentConfig.enabled) {
+        return { value, redacted: false };
+    }
+    const maxDepth = options.maxDepth ?? currentConfig.maxDepth;
+    if (value === null || value === undefined)
+        return { value, redacted: false };
+    if (typeof value === 'string') {
+        const result = redactSensitiveString(value, options);
+        return { value: result.value, redacted: result.redacted };
+    }
+    if (typeof value !== 'object') {
+        return { value, redacted: false };
+    }
+    if (state.depth >= maxDepth) {
+        return { value, redacted: false };
+    }
+    const obj = value;
+    if (state.seen.has(obj))
+        return { value, redacted: false };
+    state.seen.add(obj);
+    if (Array.isArray(value)) {
+        let redacted = false;
+        const next = value.map((item) => {
+            const result = redactSensitiveValue(item, options, {
+                depth: state.depth + 1,
+                seen: state.seen,
+            });
+            redacted = redacted || result.redacted;
+            return result.value;
+        });
+        return { value: next, redacted };
+    }
+    let redacted = false;
+    const out = {};
+    for (const [key, val] of Object.entries(obj)) {
+        const denylist = currentConfig.keyDenylist ?? [];
+        if (denylist.includes(key)) {
+            redacted = true;
+            out[key] = options.mark ?? currentConfig.mark;
+            continue;
+        }
+        const result = redactSensitiveValue(val, options, {
+            depth: state.depth + 1,
+            seen: state.seen,
+        });
+        redacted = redacted || result.redacted;
+        out[key] = result.value;
+    }
+    if (redacted) {
+        redactionCount += 1;
+    }
+    return { value: out, redacted };
+}
+//# sourceMappingURL=redaction.js.map

package/dist/core/session/compression.js

@@ -0,0 +1,323 @@
+import { promisify } from 'util';
+import { gzip, gunzip } from 'zlib';
+import { FileAdapter } from '../adapters/fs/index.js';
+export const DEFAULT_COMPRESSION_CONFIG = {
+    maxKeyMessages: 20,
+    maxKeyIterations: 10,
+};
+const gzipAsync = promisify(gzip);
+const gunzipAsync = promisify(gunzip);
+/**
+ * Simple binary serialization using JSON + compression
+ * This avoids external dependencies while still providing compression
+ */
+function serializeToBinary(data) {
+    const jsonString = JSON.stringify(data);
+    return new TextEncoder().encode(jsonString);
+}
+function deserializeFromBinary(data) {
+    const jsonString = new TextDecoder().decode(data);
+    return JSON.parse(jsonString);
+}
+/**
+ * Session compressor
+ */
+export class SessionCompressor {
+    config;
+    summaryGenerator;
+    constructor(config = DEFAULT_COMPRESSION_CONFIG) {
+        this.config = config;
+        this.summaryGenerator = new SessionSummaryGenerator();
+    }
+    /**
+     * Compress session
+     */
+    async compress(session, importanceScore) {
+        const originalSize = this.calculateSessionSize(session);
+        // Generate session summary
+        const summary = await this.summaryGenerator.generateSummary(session);
+        // Extract key messages
+        const keyMessages = this.extractKeyMessages(session.messages);
+        // Extract key iterations
+        const keyIterations = this.extractKeyIterations(session.iterations);
+        // Calculate statistics
+        const stats = this.calculateStats(session);
+        // Build compressed session
+        const compressed = {
+            meta: {
+                id: session.meta.id,
+                name: session.meta.name,
+                createdAt: session.meta.createdAt,
+                updatedAt: session.meta.updatedAt,
+                importanceScore,
+                originalSize,
+                compressedSize: 0, // Will be updated after serialization
+                compressionRatio: 0, // Will be calculated after serialization
+            },
+            compressed: {
+                summary: summary.text,
+                summaryTokens: summary.tokenCount,
+                keyMessages,
+                keyIterations,
+                stats,
+            },
+            accessInfo: {
+                lastAccessed: Date.now(),
+                accessCount: 1,
+                accessFrequency: 0,
+            },
+        };
+        // Serialize and compress
+        const serialized = serializeToBinary(compressed);
+        const compressedData = await gzipAsync(serialized);
+        // Set actual sizes
+        compressed.meta.compressedSize = compressedData.length;
+        const ratio = 1 - compressedData.length / originalSize;
+        compressed.meta.compressionRatio = Math.round(ratio * 100);
+        return compressed;
+    }
+    /**
+     * Convert session to binary compressed format
+     */
+    async compressToBinary(session, importanceScore) {
+        const compressed = await this.compress(session, importanceScore);
+        const serialized = serializeToBinary(compressed);
+        return await gzipAsync(serialized);
+    }
+    /**
+     * Decompress session from binary data
+     */
+    async decompressFromBinary(data) {
+        const decompressed = await gunzipAsync(data);
+        return deserializeFromBinary(decompressed);
+    }
+    /**
+     * Decompress and reconstruct original session (partial reconstruction)
+     */
+    async decompressToSession(compressed) {
+        return {
+            meta: {
+                id: compressed.meta.id,
+                name: compressed.meta.name,
+                createdAt: compressed.meta.createdAt,
+                updatedAt: compressed.meta.updatedAt,
+                repoPath: '', // Will be restored from full data
+                totalIterations: compressed.compressed.stats.totalIterations,
+                successfulIterations: compressed.compressed.stats.successfulIterations,
+                totalTokens: compressed.compressed.stats.totalTokens,
+                snapshots: [], // Will be restored from full data
+            },
+            messages: compressed.compressed.keyMessages.map((msg) => ({
+                role: msg.role,
+                content: msg.preview + '...', // Simplified, need full data for complete restoration
+                timestamp: msg.timestamp,
+            })),
+            iterations: compressed.compressed.keyIterations.map((iter) => ({
+                id: iter.id,
+                outcome: iter.outcome,
+                timestamp: iter.timestamp,
+                summary: iter.summary,
+                errorCount: iter.errorCount,
+            })),
+        };
+    }
+    calculateSessionSize(session) {
+        return JSON.stringify(session).length;
+    }
+    extractKeyMessages(messages) {
+        const keyMessages = [];
+        // Extract important messages: user instructions, key responses, error messages
+        for (const msg of messages) {
+            let isKey = false;
+            // User messages are typically key
+            if (msg.role === 'user') {
+                isKey = true;
+            }
+            // Assistant messages containing errors or warnings
+            if (msg.role === 'assistant' &&
+                (msg.content.includes('error') ||
+                    msg.content.includes('Error') ||
+                    msg.content.includes('failed') ||
+                    msg.content.includes('Failed'))) {
+                isKey = true;
+            }
+            // Long assistant messages may contain important information
+            if (msg.role === 'assistant' && msg.content.length > 500) {
+                isKey = true;
+            }
+            if (isKey) {
+                keyMessages.push({
+                    role: msg.role,
+                    timestamp: msg.timestamp,
+                    preview: msg.content.slice(0, 100),
+                    tokenCount: Math.ceil(msg.content.length / 4), // Rough estimation
+                });
+            }
+        }
+        // Limit the number of key messages
+        return keyMessages.slice(0, 20);
+    }
+    extractKeyIterations(iterations) {
+        return iterations.slice(-10).map((iter) => ({
+            id: iter.id,
+            outcome: this.determineOutcome(iter),
+            timestamp: iter.timestamp || Date.now(),
+            summary: this.generateIterationSummary(iter),
+            errorCount: this.countErrors(iter),
+        }));
+    }
+    calculateStats(session) {
+        const stats = {
+            totalMessages: session.messages.length,
+            userMessages: session.messages.filter((m) => m.role === 'user').length,
+            assistantMessages: session.messages.filter((m) => m.role === 'assistant').length,
+            totalIterations: session.iterations.length,
+            successfulIterations: session.meta.successfulIterations,
+            totalTokens: session.meta.totalTokens,
+        };
+        return stats;
+    }
+    determineOutcome(iteration) {
+        // 简化的结果判断逻辑
+        if (iteration.result?.success === true)
+            return 'success';
+        if (iteration.result?.success === false)
+            return 'failure';
+        return 'partial';
+    }
+    generateIterationSummary(iteration) {
+        // 生成迭代的简短摘要
+        const result = iteration.result;
+        if (!result)
+            return 'No result data';
+        if (result.success) {
+            return `Success: ${result.summary || 'Task completed'}`;
+        }
+        else {
+            return `Failed: ${result.error || 'Unknown error'}`;
+        }
+    }
+    countErrors(iteration) {
+        // 计算迭代中的错误数量
+        const result = iteration.result;
+        if (!result)
+            return 0;
+        let errorCount = 0;
+        if (result.error)
+            errorCount++;
+        if (result.errors && Array.isArray(result.errors)) {
+            errorCount += result.errors.length;
+        }
+        return errorCount;
+    }
+}
+/**
+ * Session summary generator
+ */
+export class SessionSummaryGenerator {
+    /**
+     * Generate session summary
+     */
+    async generateSummary(session) {
+        // Simplified summary generation logic
+        // In actual implementation, LLM can be called here to generate smarter summaries
+        const messageCount = session.messages.length;
+        const userMessages = session.messages.filter((m) => m.role === 'user').length;
+        const iterations = session.iterations.length;
+        const successRate = iterations > 0 ? ((session.meta.successfulIterations / iterations) * 100).toFixed(1) : '0';
+        const summary = `Session ${session.meta.name} (${new Date(session.meta.createdAt).toLocaleDateString()})
+` +
+            `Messages: ${messageCount} total (${userMessages} user)
+` +
+            `Iterations: ${iterations} (${successRate}% success rate)
+` +
+            `Key topics: ${this.extractKeyTopics(session.messages).join(', ')}
+` +
+            `Status: ${this.getSessionStatus(session)}`;
+        return {
+            text: summary,
+            tokenCount: Math.ceil(summary.length / 4),
+        };
+    }
+    extractKeyTopics(messages) {
+        // Extract keywords as topics
+        const topics = new Set();
+        const keywords = ['error', 'fix', 'feature', 'test', 'refactor', 'optimize', 'debug'];
+        for (const msg of messages) {
+            const content = msg.content.toLowerCase();
+            for (const keyword of keywords) {
+                if (content.includes(keyword)) {
+                    topics.add(keyword);
+                }
+            }
+        }
+        return Array.from(topics).slice(0, 5);
+    }
+    getSessionStatus(session) {
+        const age = Date.now() - session.meta.updatedAt;
+        const daysAgo = Math.floor(age / (1000 * 60 * 60 * 24));
+        if (daysAgo === 0)
+            return 'Active today';
+        if (daysAgo === 1)
+            return 'Active yesterday';
+        if (daysAgo < 7)
+            return `Active ${daysAgo} days ago`;
+        return `Archived ${daysAgo} days ago`;
+    }
+}
+/**
+ * Compressed session storage manager
+ */
+export class CompressedSessionStore {
+    storageDir;
+    compressor;
+    fileAdapter;
+    constructor(baseDir) {
+        this.storageDir = `${baseDir}/.salmonloop/compressed-sessions`;
+        this.compressor = new SessionCompressor();
+        this.fileAdapter = new FileAdapter();
+    }
+    /**
+     * Save compressed session
+     */
+    async saveCompressed(session, importanceScore) {
+        const compressed = await this.compressor.compressToBinary(session, importanceScore);
+        const filename = `${session.meta.id}.mpack.gz`;
+        const filepath = `${this.storageDir}/${filename}`;
+        // Ensure directory exists
+        await this.ensureStorageDir();
+        // Save compressed data
+        await this.writeFile(filepath, compressed);
+        return filename;
+    }
+    /**
+     * Load compressed session
+     */
+    async loadCompressed(filename) {
+        try {
+            const filepath = `${this.storageDir}/${filename}`;
+            const data = await this.readFile(filepath);
+            return await this.compressor.decompressFromBinary(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    async ensureStorageDir() {
+        await this.fileAdapter.mkdir(this.storageDir);
+    }
+    async writeFile(path, data) {
+        // Convert Uint8Array to string for FileAdapter
+        const dataString = Buffer.from(data).toString('base64');
+        await this.fileAdapter.writeFile(path, dataString);
+    }
+    async readFile(path) {
+        const data = await this.fileAdapter.readFile(path);
+        // FileAdapter返回base64字符串，需要解码为Uint8Array
+        if (typeof data === 'string') {
+            return new Uint8Array(Buffer.from(data, 'base64'));
+        }
+        return new Uint8Array(data);
+    }
+}
+//# sourceMappingURL=compression.js.map

package/dist/core/session/flow.js

@@ -0,0 +1,85 @@
+import { randomBytes } from 'crypto';
+import { runSalmonLoop } from '../runtime/loop.js';
+/**
+ * Type-safe execution flow for chat sessions.
+ * Inspired by Grizzco DSL pattern with progressive context.
+ *
+ * Usage:
+ * ```typescript
+ * const ctx = await ChatFlow.of(baseSession)
+ *   .withInstruction('Fix bug', 'your-test-command')
+ *   .execute(llm, options)
+ *   .snapshot(checkpointManager)  // optional
+ *   .finalize();
+ * ```
+ */
+export class ChatFlow {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    /**
+     * Initialize flow with base session context
+     */
+    static of(ctx) {
+        return new ChatFlow(Promise.resolve(ctx));
+    }
+    /**
+     * Add user instruction to context
+     * Type narrows: BaseSessionCtx -> InstructionCtx
+     */
+    withInstruction(instruction, verifyCommand) {
+        return new ChatFlow(this.data.then((ctx) => ({
+            ...ctx,
+            currentInstruction: instruction,
+            verifyCommand,
+        })));
+    }
+    /**
+     * Execute SalmonLoop with current instruction
+     * Type narrows: InstructionCtx -> ExecutedCtx
+     */
+    execute(llm, options) {
+        return new ChatFlow(this.data.then(async (ctx) => {
+            const instructionCtx = ctx;
+            const result = await runSalmonLoop({
+                instruction: instructionCtx.currentInstruction,
+                verify: instructionCtx.verifyCommand,
+                repoPath: instructionCtx.repoPath,
+                llm,
+                verbose: options?.verbose,
+                onEvent: options?.onEvent,
+            });
+            const iteration = {
+                id: randomBytes(4).toString('hex'),
+                ...(result.history?.[result.history.length - 1] || {}),
+            };
+            return {
+                ...instructionCtx,
+                iteration,
+                result,
+            };
+        }));
+    }
+    /**
+     * Create checkpoint snapshot (optional step)
+     * Type narrows: ExecutedCtx -> SnapshotCtx
+     */
+    snapshot(checkpointManager) {
+        return new ChatFlow(this.data.then(async (ctx) => {
+            const executedCtx = ctx;
+            const { commitHash } = await checkpointManager.createSafeSnapshot(executedCtx.repoPath, [], `Chat iteration ${executedCtx.iteration.id}`);
+            return {
+                ...executedCtx,
+                snapshotHash: commitHash,
+            };
+        }));
+    }
+    /**
+     * Finalize flow and return typed result
+     */
+    async finalize() {
+        return this.data;
+    }
+}
+//# sourceMappingURL=flow.js.map