salmon-loop 0.2.3

package/dist/core/context/truncation/strategies/git-diff.js

@@ -0,0 +1,99 @@
+/**
+ * Git diff truncation strategy.
+ *
+ * Preserves hunk headers and file names while truncating
+ * large diff sections.
+ */
+import { DEFAULT_TRUNCATION_CONFIG } from '../types.js';
+/**
+ * Git diff truncation strategy.
+ * Preserves hunk headers and file metadata.
+ */
+export class GitDiffStrategy {
+    config;
+    name = 'git_diff';
+    supportedTypes = ['git_diff'];
+    constructor(config = DEFAULT_TRUNCATION_CONFIG) {
+        this.config = config;
+    }
+    canHandle(output) {
+        return /^diff --git\s+a\/.+\s+b\/.+|^@@\s+-\d+/m.test(output);
+    }
+    truncate(output, budget) {
+        const keyInfoPreserved = [];
+        // If output fits in budget, return as-is
+        if (output.length <= budget) {
+            return {
+                content: output,
+                wasTruncated: false,
+                strategy: this.name,
+                keyInfoPreserved: ['complete_diff'],
+            };
+        }
+        const lines = output.split('\n');
+        const result = [];
+        let currentLength = 0;
+        // Preserve these line types with high priority
+        const preservePatterns = [
+            /^diff --git/, // File header
+            /^index\s+/, // Index line
+            /^---\s+/, // Source file
+            /^\+\+\+\s+/, // Target file
+            /^@@\s+/, // Hunk header
+            /^new file mode/, // New file marker
+            /^deleted file mode/, // Deleted file marker
+            /^Binary files/, // Binary file marker
+        ];
+        // Track current hunk context
+        let inHunk = false;
+        let hunkStartLine = -1;
+        const hunkContextLines = 10; // Lines to keep per hunk
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const lineLength = line.length + 1; // +1 for newline
+            // Check if this line should be preserved
+            const shouldPreserve = preservePatterns.some((p) => p.test(line));
+            if (shouldPreserve) {
+                result.push(line);
+                currentLength += lineLength;
+                if (/^@@\s+/.test(line)) {
+                    inHunk = true;
+                    hunkStartLine = i;
+                    keyInfoPreserved.push('hunk_header');
+                }
+            }
+            else if (inHunk) {
+                // In a hunk - keep context lines
+                const linesFromHunkStart = i - hunkStartLine;
+                // Keep first N lines of each hunk
+                if (linesFromHunkStart < hunkContextLines) {
+                    result.push(line);
+                    currentLength += lineLength;
+                }
+                else if (linesFromHunkStart === hunkContextLines) {
+                    // Add truncation marker
+                    result.push(this.config.truncationMarker);
+                    currentLength += this.config.truncationMarker.length;
+                    inHunk = false; // Stop preserving this hunk
+                }
+            }
+            // Check budget
+            if (currentLength > budget) {
+                // Add final truncation marker if needed
+                const lastLine = result[result.length - 1];
+                if (!lastLine?.includes('truncated')) {
+                    result.push(this.config.truncationMarker);
+                }
+                break;
+            }
+        }
+        keyInfoPreserved.push('file_headers');
+        return {
+            content: result.join('\n'),
+            wasTruncated: true,
+            strategy: this.name,
+            keyInfoPreserved,
+        };
+    }
+}
+//# sourceMappingURL=git-diff.js.map

package/dist/core/context/truncation/strategies/index.js

@@ -0,0 +1,10 @@
+/**
+ * Truncation strategies index.
+ */
+export { ErrorStackStrategy } from './error-stack.js';
+export { JsonStrategy } from './json.js';
+export { GitDiffStrategy } from './git-diff.js';
+export { LogStrategy } from './log.js';
+export { TestResultStrategy } from './test-result.js';
+export { GenericStrategy } from './generic.js';
+//# sourceMappingURL=index.js.map

package/dist/core/context/truncation/strategies/json.js

@@ -0,0 +1,142 @@
+/**
+ * JSON truncation strategy.
+ *
+ * Preserves JSON structure while truncating large arrays/objects.
+ * Keeps root structure and key names visible.
+ */
+import { DEFAULT_TRUNCATION_CONFIG } from '../types.js';
+/**
+ * JSON truncation strategy.
+ * Preserves structure while truncating large arrays/objects.
+ */
+export class JsonStrategy {
+    config;
+    name = 'json';
+    supportedTypes = ['json'];
+    constructor(config = DEFAULT_TRUNCATION_CONFIG) {
+        this.config = config;
+    }
+    canHandle(output) {
+        try {
+            JSON.parse(output);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    truncate(output, budget) {
+        const keyInfoPreserved = [];
+        // If output fits in budget, return as-is
+        if (output.length <= budget) {
+            return {
+                content: output,
+                wasTruncated: false,
+                strategy: this.name,
+                keyInfoPreserved: ['complete_json'],
+            };
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(output);
+        }
+        catch {
+            // Not valid JSON, fall back to simple truncation
+            return this.simpleTruncate(output, budget);
+        }
+        // Truncate while preserving structure
+        const truncated = this.truncateValue(parsed, budget - 100); // Reserve space for markers
+        const result = JSON.stringify(truncated.value, null, 2);
+        if (truncated.truncated) {
+            keyInfoPreserved.push('structure');
+            keyInfoPreserved.push('root_keys');
+        }
+        return {
+            content: result,
+            wasTruncated: truncated.truncated,
+            strategy: this.name,
+            keyInfoPreserved,
+        };
+    }
+    simpleTruncate(output, budget) {
+        const head = output.slice(0, Math.floor(budget / 2));
+        const tail = output.slice(-Math.floor(budget / 2));
+        return {
+            content: `${head}${this.config.truncationMarker}${tail}`,
+            wasTruncated: true,
+            strategy: 'json_simple',
+            keyInfoPreserved: ['head', 'tail'],
+        };
+    }
+    truncateValue(value, budget) {
+        if (value === null || value === undefined) {
+            return { value, truncated: false };
+        }
+        if (typeof value !== 'object') {
+            // Primitive value
+            const str = String(value);
+            if (str.length > budget) {
+                return {
+                    value: str.slice(0, budget - 20) + '...[truncated]',
+                    truncated: true,
+                };
+            }
+            return { value, truncated: false };
+        }
+        if (Array.isArray(value)) {
+            return this.truncateArray(value, budget);
+        }
+        // Object
+        return this.truncateObject(value, budget);
+    }
+    truncateArray(arr, budget) {
+        const maxItems = 10; // Max items to show at start and end
+        const result = [];
+        let truncated = false;
+        if (arr.length <= maxItems * 2) {
+            // Small array, truncate items if needed
+            for (const item of arr) {
+                const truncatedItem = this.truncateValue(item, budget / arr.length);
+                result.push(truncatedItem.value);
+                if (truncatedItem.truncated)
+                    truncated = true;
+            }
+        }
+        else {
+            // Large array, keep first and last items
+            const head = arr.slice(0, maxItems);
+            const tail = arr.slice(-maxItems);
+            for (const item of head) {
+                const truncatedItem = this.truncateValue(item, budget / (maxItems * 2));
+                result.push(truncatedItem.value);
+                if (truncatedItem.truncated)
+                    truncated = true;
+            }
+            // Add placeholder for truncated middle
+            const middleCount = arr.length - maxItems * 2;
+            result.push(`... ${middleCount} more items ...`);
+            truncated = true;
+            for (const item of tail) {
+                const truncatedItem = this.truncateValue(item, budget / (maxItems * 2));
+                result.push(truncatedItem.value);
+                if (truncatedItem.truncated)
+                    truncated = true;
+            }
+        }
+        return { value: result, truncated };
+    }
+    truncateObject(obj, budget) {
+        const result = {};
+        let truncated = false;
+        const entries = Object.entries(obj);
+        // Keep all keys but truncate values
+        for (const [key, value] of entries) {
+            const truncatedValue = this.truncateValue(value, budget / entries.length);
+            result[key] = truncatedValue.value;
+            if (truncatedValue.truncated)
+                truncated = true;
+        }
+        return { value: result, truncated };
+    }
+}
+//# sourceMappingURL=json.js.map

package/dist/core/context/truncation/strategies/log.js

@@ -0,0 +1,131 @@
+/**
+ * Log output truncation strategy.
+ *
+ * Preserves error/warning lines with surrounding context.
+ * Removes verbose INFO/DEBUG lines when necessary.
+ */
+import { DEFAULT_TRUNCATION_CONFIG } from '../types.js';
+/**
+ * Log level priority for filtering.
+ */
+const LOG_LEVEL_PRIORITY = {
+    FATAL: 100,
+    ERROR: 90,
+    ERR: 90,
+    CRITICAL: 80,
+    CRIT: 80,
+    WARN: 70,
+    WARNING: 70,
+    INFO: 50,
+    DEBUG: 30,
+    TRACE: 20,
+    VERBOSE: 10,
+};
+/**
+ * Log output truncation strategy.
+ * Prioritizes error and warning lines.
+ */
+export class LogStrategy {
+    config;
+    name = 'log';
+    supportedTypes = ['log'];
+    constructor(config = DEFAULT_TRUNCATION_CONFIG) {
+        this.config = config;
+    }
+    canHandle(output) {
+        return /^\s*(ERROR|WARN|INFO|DEBUG|TRACE|FATAL)\s*[:[\]|]/m.test(output);
+    }
+    truncate(output, budget) {
+        const keyInfoPreserved = [];
+        // If output fits in budget, return as-is
+        if (output.length <= budget) {
+            return {
+                content: output,
+                wasTruncated: false,
+                strategy: this.name,
+                keyInfoPreserved: ['complete_log'],
+            };
+        }
+        const lines = output.split('\n');
+        // Score each line by importance
+        const scoredLines = lines.map((line, index) => ({
+            index,
+            line,
+            score: this.scoreLine(line),
+        }));
+        // Sort by score (highest first)
+        const sortedByScore = [...scoredLines].sort((a, b) => b.score - a.score);
+        // Select lines until budget is exhausted
+        const selectedIndices = new Set();
+        let currentLength = 0;
+        for (const { index, line } of sortedByScore) {
+            const lineLength = line.length + 1;
+            if (currentLength + lineLength > budget) {
+                break;
+            }
+            selectedIndices.add(index);
+            currentLength += lineLength;
+            // Add context lines around important lines
+            for (let j = Math.max(0, index - this.config.contextLines); j <= Math.min(lines.length - 1, index + this.config.contextLines); j++) {
+                if (!selectedIndices.has(j)) {
+                    const contextLine = lines[j];
+                    const contextLength = contextLine.length + 1;
+                    if (currentLength + contextLength <= budget) {
+                        selectedIndices.add(j);
+                        currentLength += contextLength;
+                    }
+                }
+            }
+        }
+        // Build result in original order
+        const result = [];
+        let lastAdded = -2;
+        const sortedIndices = Array.from(selectedIndices).sort((a, b) => a - b);
+        for (const index of sortedIndices) {
+            // Add truncation marker for gaps
+            if (index > lastAdded + 1 && lastAdded >= 0) {
+                result.push(this.config.truncationMarker);
+            }
+            result.push(lines[index]);
+            lastAdded = index;
+        }
+        // Track what was preserved
+        const errorCount = lines.filter((l) => this.scoreLine(l) >= 90).length;
+        const warnCount = lines.filter((l) => this.scoreLine(l) >= 70 && this.scoreLine(l) < 90).length;
+        if (errorCount > 0)
+            keyInfoPreserved.push('error_lines');
+        if (warnCount > 0)
+            keyInfoPreserved.push('warning_lines');
+        keyInfoPreserved.push('context');
+        return {
+            content: result.join('\n'),
+            wasTruncated: true,
+            strategy: this.name,
+            keyInfoPreserved,
+        };
+    }
+    /**
+     * Score a log line by importance.
+     * Higher score = more important to preserve.
+     */
+    scoreLine(line) {
+        const upperLine = line.toUpperCase();
+        // Check for log level indicators
+        for (const [level, priority] of Object.entries(LOG_LEVEL_PRIORITY)) {
+            if (upperLine.includes(level)) {
+                return priority;
+            }
+        }
+        // Check for error-like patterns
+        if (/exception|failed|failure|error|crash/i.test(line)) {
+            return 85;
+        }
+        // Timestamps are moderately important
+        if (/^\s*\d{4}-\d{2}-\d{2}/.test(line)) {
+            return 40;
+        }
+        // Default low priority
+        return 10;
+    }
+}
+//# sourceMappingURL=log.js.map

package/dist/core/context/truncation/strategies/test-result.js

@@ -0,0 +1,140 @@
+/**
+ * Test result truncation strategy.
+ *
+ * Preserves failed test information, error messages, and summary.
+ * Truncates passing test details and verbose output.
+ */
+import { DEFAULT_TRUNCATION_CONFIG } from '../types.js';
+/**
+ * Test result truncation strategy.
+ * Prioritizes failed tests and error messages.
+ */
+export class TestResultStrategy {
+    config;
+    name = 'test_result';
+    supportedTypes = ['test_result'];
+    constructor(config = DEFAULT_TRUNCATION_CONFIG) {
+        this.config = config;
+    }
+    canHandle(output) {
+        return (/\d+\s+(passed|failed|skipped)/i.test(output) ||
+            /FAIL\s*[(:]/i.test(output) ||
+            /✓|✗|✅|❌/.test(output) ||
+            /FAILURES:/i.test(output));
+    }
+    truncate(output, budget) {
+        const keyInfoPreserved = [];
+        // If output fits in budget, return as-is
+        if (output.length <= budget) {
+            return {
+                content: output,
+                wasTruncated: false,
+                strategy: this.name,
+                keyInfoPreserved: ['complete_results'],
+            };
+        }
+        const lines = output.split('\n');
+        // Categorize lines
+        const categories = {
+            summary: [], // Summary lines (X passed, Y failed)
+            failures: [], // Failure headers
+            errors: [], // Error messages
+            stackTraces: [], // Stack traces
+            passing: [], // Passing test lines
+            other: [], // Other lines
+        };
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (/^\s*Tests?\s*:\s*\d+/.test(line) || /^\s*Passing\s*:\s*\d+/.test(line)) {
+                categories.summary.push(i);
+            }
+            else if (/^\s*Failing\s*:\s*\d+/.test(line) || /FAIL\s*[(:]/i.test(line)) {
+                categories.failures.push(i);
+            }
+            else if (/^\s*✗|^\s*✘|^\s*FAIL|AssertionError/i.test(line)) {
+                categories.failures.push(i);
+            }
+            else if (/^\s+at\s+.+\(/.test(line) || /^\s+at\s+\w+/.test(line)) {
+                categories.stackTraces.push(i);
+            }
+            else if (/^\s*✓|^\s*✔|^\s*PASS/i.test(line)) {
+                categories.passing.push(i);
+            }
+            else if (/Error:|expected|actual|received/i.test(line)) {
+                categories.errors.push(i);
+            }
+            else {
+                categories.other.push(i);
+            }
+        }
+        // Select lines by priority
+        const selectedIndices = new Set();
+        let currentLength = 0;
+        // Priority order: summary > failures > errors > stack traces > other > passing
+        const priorityOrder = [
+            'summary',
+            'failures',
+            'errors',
+            'stackTraces',
+            'other',
+            'passing',
+        ];
+        for (const category of priorityOrder) {
+            const indices = categories[category];
+            const maxLines = category === 'passing' ? 5 : Infinity; // Limit passing lines
+            let addedFromCategory = 0;
+            for (const index of indices) {
+                if (addedFromCategory >= maxLines)
+                    break;
+                const line = lines[index];
+                const lineLength = line.length + 1;
+                if (currentLength + lineLength > budget) {
+                    break;
+                }
+                // Add context for failures
+                if (category === 'failures' || category === 'errors') {
+                    for (let j = Math.max(0, index - this.config.contextLines); j <= Math.min(lines.length - 1, index + this.config.contextLines); j++) {
+                        if (!selectedIndices.has(j)) {
+                            const contextLine = lines[j];
+                            const contextLength = contextLine.length + 1;
+                            if (currentLength + contextLength <= budget) {
+                                selectedIndices.add(j);
+                                currentLength += contextLength;
+                            }
+                        }
+                    }
+                }
+                if (!selectedIndices.has(index)) {
+                    selectedIndices.add(index);
+                    currentLength += lineLength;
+                }
+                addedFromCategory++;
+            }
+        }
+        // Build result in original order
+        const result = [];
+        let lastAdded = -2;
+        const sortedIndices = Array.from(selectedIndices).sort((a, b) => a - b);
+        for (const index of sortedIndices) {
+            if (index > lastAdded + 1 && lastAdded >= 0) {
+                result.push(this.config.truncationMarker);
+            }
+            result.push(lines[index]);
+            lastAdded = index;
+        }
+        // Track what was preserved
+        if (categories.summary.length > 0)
+            keyInfoPreserved.push('summary');
+        if (categories.failures.length > 0)
+            keyInfoPreserved.push('failures');
+        if (categories.errors.length > 0)
+            keyInfoPreserved.push('errors');
+        return {
+            content: result.join('\n'),
+            wasTruncated: true,
+            strategy: this.name,
+            keyInfoPreserved,
+        };
+    }
+}
+//# sourceMappingURL=test-result.js.map

package/dist/core/context/truncation/type-detector.js

@@ -0,0 +1,133 @@
+/**
+ * Output type detection.
+ *
+ * Analyzes output content to determine the most appropriate
+ * truncation strategy.
+ */
+/**
+ * Detection patterns for each output type.
+ */
+const DETECTION_PATTERNS = {
+    error_stack: [
+        /^\s*Error:\s*.+$/m, // Error: message
+        /^\s+at\s+.+\(.+\)$/m, // at function (file:line:col)
+        /^\s*TypeError:\s*.+$/m,
+        /^\s*ReferenceError:\s*.+$/m,
+        /^\s*SyntaxError:\s*.+$/m,
+        /^\s*RuntimeError:\s*.+$/m,
+        /stack trace:/i,
+        /^\s*\w+Error:/m, // Any *Error:
+    ],
+    git_diff: [
+        /^diff --git\s+a\/.+\s+b\/.+$/m,
+        /^index\s+[a-f0-9]+\.\.[a-f0-9]+/m,
+        /^---\s+a\//m,
+        /^\+\+\+\s+b\//m,
+        /^@@\s+-\d+,?\d*\s+\+\d+,?\d*\s+@@/m,
+    ],
+    json: [
+        /^\s*\{[\s\S]*\}\s*$/, // Object
+        /^\s*\[[\s\S]*\]\s*$/, // Array
+    ],
+    test_result: [
+        /\d+\s+(passed|failed|skipped)/i,
+        /FAIL\s*[(:]/i,
+        /PASS\s*[(:]/i,
+        /✓|✗|✅|❌/,
+        /Test\s+\d+:/i,
+        /FAILURES:/i,
+        /\d+\s+tests?\s+(passed|failed)/i,
+    ],
+    log: [
+        /^\s*(ERROR|WARN|INFO|DEBUG|TRACE|FATAL)\s*[:[\]|]/m,
+        /^\s*\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}/m, // Timestamp
+        /^\s*\[\d{4}-\d{2}-\d{2}/m, // [YYYY-MM-DD
+        /log\s*(level|file):/i,
+    ],
+    generic: [],
+};
+/**
+ * Detect the output type based on content analysis.
+ *
+ * @param output - Raw output string
+ * @returns Detection result with type and confidence
+ */
+export function detectOutputType(output) {
+    if (!output || output.trim().length === 0) {
+        return { type: 'generic', confidence: 1.0 };
+    }
+    const scores = new Map();
+    for (const [type, patterns] of Object.entries(DETECTION_PATTERNS)) {
+        let matchCount = 0;
+        for (const pattern of patterns) {
+            if (pattern.test(output)) {
+                matchCount++;
+            }
+        }
+        if (matchCount > 0) {
+            // Score based on number of matching patterns
+            const score = matchCount / patterns.length;
+            scores.set(type, score);
+        }
+    }
+    // Find the type with highest score
+    let bestType = 'generic';
+    let bestScore = 0;
+    for (const [type, score] of scores) {
+        if (score > bestScore) {
+            bestScore = score;
+            bestType = type;
+        }
+    }
+    // Special handling for JSON - verify it parses
+    if (bestType === 'json') {
+        try {
+            JSON.parse(output);
+        }
+        catch {
+            // Not valid JSON, downgrade to generic
+            bestType = 'generic';
+            bestScore = 0;
+        }
+    }
+    return {
+        type: bestType,
+        confidence: bestScore,
+    };
+}
+/**
+ * Detect output type with hint.
+ * Hint can override detection when explicitly provided.
+ *
+ * @param output - Raw output string
+ * @param hint - Optional type hint (e.g., from tool name)
+ * @returns Detection result
+ */
+export function detectOutputTypeWithHint(output, hint) {
+    // If hint is provided, try to map it
+    if (hint) {
+        const normalizedHint = hint.toLowerCase().trim();
+        // Map common hints to types
+        const hintMap = {
+            error: 'error_stack',
+            exception: 'error_stack',
+            stacktrace: 'error_stack',
+            diff: 'git_diff',
+            git: 'git_diff',
+            json: 'json',
+            test: 'test_result',
+            tests: 'test_result',
+            verify: 'test_result',
+            log: 'log',
+            logs: 'log',
+        };
+        for (const [key, type] of Object.entries(hintMap)) {
+            if (normalizedHint.includes(key)) {
+                return { type, confidence: 1.0 };
+            }
+        }
+    }
+    // Fall back to content-based detection
+    return detectOutputType(output);
+}
+//# sourceMappingURL=type-detector.js.map

package/dist/core/context/truncation/types.js

@@ -0,0 +1,16 @@
+/**
+ * Semantic truncation types and interfaces.
+ *
+ * Provides type-aware truncation for tool outputs to preserve
+ * critical information while staying within token budgets.
+ */
+/**
+ * Default truncation configuration.
+ */
+export const DEFAULT_TRUNCATION_CONFIG = {
+    defaultBudget: 4000,
+    minBudget: 500,
+    truncationMarker: '\n... [truncated] ...\n',
+    contextLines: 3,
+};
+//# sourceMappingURL=types.js.map

package/dist/core/context/types.js

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