salmon-loop 0.2.3

package/dist/core/context/builder.js

@@ -0,0 +1,289 @@
+import { FileAdapter } from '../adapters/fs/file-adapter.js';
+import { defaultPathAdapter } from '../adapters/path/path-adapter.js';
+import { ConfigError } from '../config/errors.js';
+import { LIMITS } from '../config/limits.js';
+import { resolveConfig } from '../config/resolve.js';
+import { createDefaultPermissionGate } from '../permission-gate/default-gate.js';
+import { ensureInSandbox, normalizePath } from '../utils/path.js';
+/**
+ * Base extensions that should always be recognized for error file extraction.
+ * These are common config and documentation files that may appear in any project.
+ */
+const BASE_EXTENSIONS = ['json', 'md', 'txt', 'yaml', 'yml', 'toml', 'lock', 'log'];
+/**
+ * Build dynamic file extension pattern for regex matching.
+ * Combines plugin-registered extensions with base extensions for robustness.
+ * Returns extensions without leading dots for regex alternation: (?:ts|js|tsx|...)
+ */
+function getExtensionsPattern() {
+    const extensions = new Set(BASE_EXTENSIONS);
+    return Array.from(extensions).join('|');
+}
+function getExtensionsPatternForPlugins(plugins) {
+    const extensions = new Set(BASE_EXTENSIONS);
+    for (const plugin of plugins) {
+        for (const ext of plugin.meta.extensions) {
+            // Strip leading dot for regex alternation
+            extensions.add(ext.startsWith('.') ? ext.slice(1) : ext);
+        }
+    }
+    return Array.from(extensions).join('|');
+}
+const fileAdapter = new FileAdapter();
+import { outlineSource } from './ast/source-outline.js';
+import { createContextCacheStore } from './cache/store-factory.js';
+import { applySmartCompression } from './compression/smart-compress.js';
+import { findFileDependencies } from './dependencies.js';
+import { buildContextBudgetPolicyPlan, executeContextBudgetPolicyPlan, } from './policies/budget-policy.js';
+import { packUntilFull } from './policies/pack-until-full.js';
+import { rankContextForRelevance } from './scoring/relevance.js';
+import { calculateSectionChars } from './service-helpers.js';
+import { ContextService } from './service.js';
+function toShrinkOptions(value) {
+    if (!value)
+        return {};
+    if (typeof value === 'object')
+        return value;
+    return { errorType: value };
+}
+function uniqNormalizedPaths(paths) {
+    const seen = new Set();
+    const out = [];
+    for (const p of paths) {
+        const normalized = normalizePath(p).replace(/^(\.\/|\/)+/, '');
+        if (!normalized)
+            continue;
+        if (seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}
+function mergeTargets(existing, failedFiles) {
+    const out = [...(existing ?? [])];
+    const seen = new Set(out.map((t) => normalizePath(t.path).replace(/^(\.\/|\/)+/, '')));
+    for (const file of failedFiles) {
+        const normalized = normalizePath(file).replace(/^(\.\/|\/)+/, '');
+        if (!normalized)
+            continue;
+        if (seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push({
+            path: normalized,
+            reason: 'failed_file',
+            confidence: 'high',
+            evidence: 'verify_output',
+        });
+    }
+    return out;
+}
+async function readRepoFileText(repoPath, relativePath) {
+    try {
+        const normalized = normalizePath(relativePath).replace(/^(\.\/|\/)+/, '');
+        const fullPath = ensureInSandbox(repoPath, defaultPathAdapter.join(repoPath, normalized));
+        return await fileAdapter.readFile(fullPath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+export class ContextBuilder {
+    static async build(options) {
+        const config = await resolveConfig({ repoRoot: options.repoPath });
+        const permissionGate = createDefaultPermissionGate({
+            allowOutsideCacheRoot: options.allowOutsideCacheRoot,
+            authorizationProvider: options.authorizationProvider,
+            repoRoot: options.repoPath,
+        });
+        let cacheConfig;
+        try {
+            cacheConfig = await createContextCacheStore(options.repoPath, config.raw, {
+                permissionGate,
+            });
+        }
+        catch (error) {
+            const requestId = error instanceof ConfigError &&
+                error.code === 'PERMISSION_REQUIRED_CONTEXT_CACHE_OUTSIDE_ROOT'
+                ? error.details?.requestId
+                : undefined;
+            if (!requestId || !permissionGate.waitForAuthorization) {
+                throw error;
+            }
+            const decision = await permissionGate.waitForAuthorization(requestId, options.signal);
+            if (decision?.kind === 'allow') {
+                cacheConfig = await createContextCacheStore(options.repoPath, config.raw, {
+                    permissionGate,
+                });
+            }
+            else {
+                throw error;
+            }
+        }
+        const service = new ContextService({}, {
+            cacheStore: cacheConfig.store,
+            cacheMaxEntries: cacheConfig.maxEntries,
+            cacheTtlMs: cacheConfig.ttlMs,
+        });
+        const result = await service.build({
+            instruction: options.instruction,
+            repoPath: options.repoPath,
+            primaryFile: options.file,
+            selection: options.selection,
+            snapshotHash: options.snapshotHash,
+            checkpointManager: options.checkpointManager,
+            signal: options.signal,
+        });
+        return result;
+    }
+    static tuneContext(context, budgetChars) {
+        return rankContextForRelevance(applySmartCompression(context, { budgetChars }));
+    }
+    static packRankedContext(context, budgetChars) {
+        const preBudgetSectionChars = calculateSectionChars(context);
+        const plan = buildContextBudgetPolicyPlan({
+            requestedBudgetChars: budgetChars,
+            preBudgetSectionChars,
+            targetCount: (context.targets ?? []).length,
+        });
+        const packed = executeContextBudgetPolicyPlan({
+            plan,
+            context,
+            fallbackBudgetChars: budgetChars,
+            pack: packUntilFull,
+        });
+        return packed.context;
+    }
+    static tuneAndPackContext(context, budgetChars) {
+        const tuned = this.tuneContext(context, budgetChars);
+        return this.packRankedContext(tuned, budgetChars);
+    }
+    /**
+     * Extract potential failed file paths from verification output.
+     * Uses dynamically registered extensions from plugin registry.
+     */
+    static extractFailedFiles(verifyOutput, deps) {
+        const uniqueFiles = new Set();
+        const extPattern = deps?.languagePlugins
+            ? getExtensionsPatternForPlugins(deps.languagePlugins.getAll())
+            : getExtensionsPattern();
+        // Strategy 1: Look for file paths followed by line numbers (common in stack traces and compiler output)
+        // We handle both quoted and unquoted paths.
+        const patterns = [
+            // Quoted paths (can contain spaces)
+            new RegExp(`"([^"\\n]+\\.(?:${extPattern}))"[:(]\\d+`, 'gu'),
+            // Unquoted paths (no spaces allowed to avoid over-matching)
+            new RegExp(`((?:[a-zA-Z]:)?[^\\s:()"]+\\.(?:${extPattern}))[:(]\\d+`, 'gu'),
+        ];
+        for (const pattern of patterns) {
+            let match;
+            while ((match = pattern.exec(verifyOutput)) !== null) {
+                let p = normalizePath(match[1].trim());
+                p = p.replace(/^(\.\/|\/)/, '');
+                p = p.replace(/^[a-zA-Z]:\//, '');
+                uniqueFiles.add(p);
+            }
+        }
+        // Strategy 2: Fall back to general file path matching for paths without line numbers
+        const pathPattern = new RegExp(`(?:^|\\s)((?:[a-zA-Z]:)?[^\\s:()"]+\\.(?:${extPattern}))\\b`, 'gu');
+        let match2;
+        while ((match2 = pathPattern.exec(verifyOutput)) !== null) {
+            let p = normalizePath(match2[1].trim());
+            p = p.replace(/^(\.\/|\/)/, '');
+            p = p.replace(/^[a-zA-Z]:\//, '');
+            uniqueFiles.add(p);
+        }
+        // Filter out node_modules and .git
+        return Array.from(uniqueFiles).filter((file) => !file.includes('node_modules') && !file.startsWith('.git'));
+    }
+    /**
+     * Shrink context based on failed files, error type and token limits.
+     * Uses deterministic rules: failed files + limited static dependencies.
+     * Protects against over-shrinking by falling back to original context if budget allows.
+     */
+    static async shrinkContext(context, failedFiles, errorTypeOrOptions) {
+        const budgetChars = LIMITS.maxContextChars;
+        const options = toShrinkOptions(errorTypeOrOptions);
+        const dependencyDepth = Math.max(1, Math.min(LIMITS.maxDependencyDepth, options.dependencyDepth ?? 1));
+        // Normalize failed file paths
+        const normalizedFailed = uniqNormalizedPaths(failedFiles);
+        if (normalizedFailed.length > 0) {
+            const dependencyPromises = normalizedFailed.map((f) => findFileDependencies(f, context.repoPath, {
+                depth: dependencyDepth,
+                maxFiles: LIMITS.maxRelatedFiles,
+            }).catch(() => []));
+            const dependenciesArrays = await Promise.all(dependencyPromises);
+            const dependencyList = uniqNormalizedPaths(dependenciesArrays.flat());
+            const selectedPaths = uniqNormalizedPaths([
+                ...normalizedFailed,
+                ...dependencyList.slice(0, LIMITS.maxRelatedFiles),
+            ]);
+            const existingByPath = new Map();
+            for (const f of context.relatedFiles ?? []) {
+                existingByPath.set(normalizePath(f.path), f);
+            }
+            const newRelatedFiles = [];
+            for (const p of selectedPaths) {
+                if (p === context.primaryFile)
+                    continue;
+                const existing = existingByPath.get(normalizePath(p));
+                if (existing) {
+                    newRelatedFiles.push({
+                        ...existing,
+                        kind: normalizedFailed.includes(p) ? 'failed' : 'dependency',
+                    });
+                    continue;
+                }
+                const content = await readRepoFileText(context.repoPath, p);
+                if (content === null)
+                    continue;
+                const isLarge = content.length > LIMITS.largeFileThresholdBytes;
+                const outline = outlineSource(content);
+                newRelatedFiles.push({
+                    path: p,
+                    kind: normalizedFailed.includes(p) ? 'failed' : 'dependency',
+                    mode: isLarge ? 'outline' : 'full',
+                    content: isLarge ? outline : content,
+                    outline: isLarge ? undefined : outline || undefined,
+                });
+            }
+            let newSnippets = context.rgSnippets.filter((snippet) => {
+                const normalizedSnippetFile = normalizePath(snippet.file);
+                return selectedPaths.some((related) => normalizedSnippetFile.endsWith(related));
+            });
+            // Cap snippets after shrink to keep context focused
+            newSnippets = newSnippets.slice(0, LIMITS.maxSnippetsAfterShrink);
+            const shrunkContext = {
+                ...context,
+                relatedFiles: newRelatedFiles,
+                rgSnippets: newSnippets,
+                targets: mergeTargets(context.targets, normalizedFailed),
+            };
+            const tuned = this.tuneContext(shrunkContext, budgetChars);
+            // Protection against over-shrinking: if shrunk context is too small,
+            // fallback to original context (but still truncated to max budget)
+            if (this.calculateTotalChars(tuned) < LIMITS.minContextChars) {
+                return this.tuneAndPackContext(context, budgetChars);
+            }
+            return this.packRankedContext(tuned, budgetChars);
+        }
+        // If no failed files, keep original keyword matches but ensure they are within limits
+        return this.tuneAndPackContext(context, budgetChars);
+    }
+    /**
+     * Calculates approximate context size in characters.
+     * NOTE: This is NOT token count. Used only for heuristic limits and shrinking.
+     */
+    static calculateTotalChars(context) {
+        const primary = context.primaryText?.length ?? 0;
+        const related = context.relatedFiles?.reduce((sum, file) => sum + (file.content?.length ?? 0), 0) ?? 0;
+        const snippets = context.rgSnippets.reduce((sum, snippet) => sum + (snippet.content?.length ?? 0), 0);
+        const diff = (context.gitDiff?.length ?? 0) +
+            (context.stagedDiff?.length ?? 0) +
+            (context.unstagedDiff?.length ?? 0) +
+            (context.untrackedDiff?.length ?? 0);
+        return primary + related + snippets + diff;
+    }
+}
+//# sourceMappingURL=builder.js.map

package/dist/core/context/cache/errors.js

@@ -0,0 +1,16 @@
+import { SalmonError } from '../../types/errors.js';
+export class ContextCacheError extends SalmonError {
+    code;
+    filePath;
+    remediation;
+    original;
+    constructor(code, filePath, remediation, message, original) {
+        super(`${code}: ${message}`, code);
+        this.code = code;
+        this.filePath = filePath;
+        this.remediation = remediation;
+        this.original = original;
+        this.name = 'ContextCacheError';
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/core/context/cache/incremental-updater.js

@@ -0,0 +1,131 @@
+/**
+ * Incremental context updater.
+ *
+ * Computes diffs between context versions and applies incremental updates.
+ */
+/**
+ * Incremental context updater.
+ *
+ * Tracks changes between context versions for efficient updates.
+ */
+export class IncrementalUpdater {
+    previousContext = null;
+    previousTokenCount = 0;
+    /**
+     * Compute diff between previous and new context.
+     */
+    computeDiff(newContext) {
+        const diff = {
+            addedFiles: [],
+            removedFiles: [],
+            modifiedFiles: [],
+            tokenDelta: 0,
+            primaryChanged: false,
+            snippetsChanged: false,
+            diffsChanged: false,
+        };
+        if (!this.previousContext) {
+            // First context, everything is new
+            if (newContext.relatedFiles) {
+                diff.addedFiles = newContext.relatedFiles.map((f) => f.path);
+            }
+            diff.primaryChanged = !!newContext.primaryText;
+            diff.snippetsChanged = newContext.rgSnippets.length > 0;
+            diff.diffsChanged = !!(newContext.gitDiff || newContext.stagedDiff);
+            this.previousContext = newContext;
+            return diff;
+        }
+        // Compare related files
+        const prevFiles = new Map((this.previousContext.relatedFiles || []).map((f) => [f.path, f.content]));
+        const newFiles = new Map((newContext.relatedFiles || []).map((f) => [f.path, f.content]));
+        // Find added and modified files
+        for (const [path, content] of newFiles) {
+            const prevContent = prevFiles.get(path);
+            if (!prevContent) {
+                diff.addedFiles.push(path);
+            }
+            else if (prevContent !== content) {
+                diff.modifiedFiles.push(path);
+            }
+        }
+        // Find removed files
+        for (const path of prevFiles.keys()) {
+            if (!newFiles.has(path)) {
+                diff.removedFiles.push(path);
+            }
+        }
+        // Check primary text
+        diff.primaryChanged = this.previousContext.primaryText !== newContext.primaryText;
+        // Check snippets
+        diff.snippetsChanged = this.hasSnippetsChanged(this.previousContext.rgSnippets, newContext.rgSnippets);
+        // Check diffs
+        diff.diffsChanged =
+            this.previousContext.gitDiff !== newContext.gitDiff ||
+                this.previousContext.stagedDiff !== newContext.stagedDiff ||
+                this.previousContext.unstagedDiff !== newContext.unstagedDiff ||
+                this.previousContext.untrackedDiff !== newContext.untrackedDiff;
+        // Update previous context
+        this.previousContext = newContext;
+        return diff;
+    }
+    /**
+     * Check if snippets changed.
+     */
+    hasSnippetsChanged(prev, current) {
+        if (prev.length !== current.length)
+            return true;
+        for (let i = 0; i < prev.length; i++) {
+            if (prev[i].file !== current[i].file ||
+                prev[i].content !== current[i].content ||
+                prev[i].line !== current[i].line) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Set token count for delta calculation.
+     */
+    setTokenCount(count) {
+        this.previousTokenCount = count;
+    }
+    /**
+     * Get previous token count.
+     */
+    getPreviousTokenCount() {
+        return this.previousTokenCount;
+    }
+    /**
+     * Reset state.
+     */
+    reset() {
+        this.previousContext = null;
+        this.previousTokenCount = 0;
+    }
+    /**
+     * Get previous context.
+     */
+    getPreviousContext() {
+        return this.previousContext;
+    }
+}
+/**
+ * Global incremental updater instance.
+ */
+let globalInstance = null;
+/**
+ * Get global incremental updater.
+ */
+export function getIncrementalUpdater() {
+    if (!globalInstance) {
+        globalInstance = new IncrementalUpdater();
+    }
+    return globalInstance;
+}
+/**
+ * Reset global instance (for testing).
+ */
+export function resetIncrementalUpdater() {
+    globalInstance = null;
+}
+//# sourceMappingURL=incremental-updater.js.map

package/dist/core/context/cache/index.js

@@ -0,0 +1,25 @@
+/**
+ * Context caching module.
+ *
+ * Provides caching infrastructure for context management:
+ * - File-level token caching (via TokenCache)
+ * - Prompt caching for Claude/OpenAI/Gemini
+ * - Incremental context updates
+ *
+ * @example
+ * ```typescript
+ * import { PromptCachingManager, getIncrementalUpdater } from './cache/index.js';
+ *
+ * // Prompt caching
+ * const caching = new PromptCachingManager();
+ * const { system, messages } = caching.prepareClaudeMessages(sysPrompt, context);
+ *
+ * // Incremental updates
+ * const updater = getIncrementalUpdater();
+ * const diff = updater.computeDiff(newContext);
+ * ```
+ */
+export { PromptCachingManager, getPromptCachingManager, resetPromptCachingManager, } from './prompt-caching.js';
+export { IncrementalUpdater, getIncrementalUpdater, resetIncrementalUpdater, } from './incremental-updater.js';
+export { DEFAULT_PROMPT_CACHING_CONFIG } from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/core/context/cache/path-resolver.js

@@ -0,0 +1,127 @@
+import { FileAdapter } from '../../adapters/fs/file-adapter.js';
+import { defaultPathAdapter } from '../../adapters/path/path-adapter.js';
+import { ConfigError } from '../../config/errors.js';
+import { recordAuditEvent } from '../../observability/audit-trail.js';
+import { isPathWithinDirectory } from '../../utils/path.js';
+export async function resolveContextCachePath(repoPath, rawConfig, options, pathAdapter = defaultPathAdapter) {
+    const cacheConfig = rawConfig?.context?.cache;
+    const mode = cacheConfig?.mode ?? 'memory';
+    if (mode !== 'persistent')
+        return { mode: 'memory' };
+    if (!cacheConfig?.path || typeof cacheConfig.path !== 'string') {
+        throw new ConfigError('CONFIG_INVALID_CONTEXT_CACHE_PATH', { expected: 'non-empty string' });
+    }
+    if (!Array.isArray(cacheConfig.allowedRoots) ||
+        cacheConfig.allowedRoots.length === 0 ||
+        cacheConfig.allowedRoots.some((root) => typeof root !== 'string' || root.length === 0)) {
+        throw new ConfigError('CONFIG_INVALID_CONTEXT_CACHE_ALLOWED_ROOTS', {
+            expected: 'non-empty string[]',
+        });
+    }
+    const fileAdapter = options?.fileAdapter ?? new FileAdapter();
+    const resolvedPath = pathAdapter.resolve(repoPath, cacheConfig.path);
+    const resolvedRoots = cacheConfig.allowedRoots.map((root) => pathAdapter.resolve(repoPath, root));
+    await ensureAllowedRootsAccessible(resolvedRoots, fileAdapter);
+    const canonicalPath = await resolveCanonicalPath(resolvedPath, fileAdapter, pathAdapter);
+    const canonicalRoots = await Promise.all(resolvedRoots.map(async (root) => await resolveCanonicalPath(root, fileAdapter, pathAdapter)));
+    const allowed = resolvedRoots.some((root) => isPathWithinDirectory(root, resolvedPath, { allowEqual: true }));
+    const canonicalAllowed = canonicalRoots.some((root) => isPathWithinDirectory(root, canonicalPath, { allowEqual: true }));
+    if (!allowed || !canonicalAllowed) {
+        const request = {
+            action: 'context.cache.outside_root',
+            resource: resolvedPath,
+            risk: 'high',
+            metadata: {
+                repoPath,
+                allowedRoots: resolvedRoots.join(','),
+                canonicalPath,
+                canonicalRoots: canonicalRoots.join(','),
+            },
+        };
+        let decision;
+        let pendingChallenge;
+        let pendingRequestId;
+        if (options?.permissionGate?.requestAuthorizationDeferred) {
+            const deferred = await options.permissionGate.requestAuthorizationDeferred(request);
+            if (deferred.kind === 'pending') {
+                pendingChallenge = deferred.challenge;
+                pendingRequestId = deferred.requestId;
+            }
+            else {
+                decision = deferred.decision;
+            }
+        }
+        else {
+            decision = await options?.permissionGate?.requestAuthorization(request);
+        }
+        recordAuditEvent('permission.decision', {
+            action: request.action,
+            resource: request.resource,
+            risk: request.risk,
+            decision: pendingChallenge ? 'pending' : (decision?.kind ?? 'deny'),
+            source: decision?.source ?? (pendingChallenge ? 'user' : 'policy'),
+            challenge: pendingChallenge ?? decision?.challengeId,
+            requestId: pendingRequestId,
+        }, { source: 'permission_gate', severity: 'high', scope: 'session', phase: 'CONTEXT' });
+        if (pendingChallenge || decision?.kind === 'challenge') {
+            throw new ConfigError('PERMISSION_REQUIRED_CONTEXT_CACHE_OUTSIDE_ROOT', {
+                path: resolvedPath,
+                allowedRoots: resolvedRoots.join(','),
+                canonicalPath,
+                canonicalRoots: canonicalRoots.join(','),
+                challenge: pendingChallenge ?? decision?.challengeId ?? '',
+                requestId: pendingRequestId ?? '',
+            });
+        }
+        if (decision?.kind !== 'allow') {
+            throw new ConfigError('PERMISSION_DENIED_CONTEXT_CACHE_OUTSIDE_ROOT', {
+                path: resolvedPath,
+                allowedRoots: resolvedRoots.join(','),
+                canonicalPath,
+                canonicalRoots: canonicalRoots.join(','),
+                reason: decision?.reason ?? 'denied',
+            });
+        }
+    }
+    return { mode: 'persistent', filePath: resolvedPath };
+}
+async function resolveCanonicalPath(resolvedPath, fileAdapter, pathAdapter) {
+    let cursor = resolvedPath;
+    const pendingSegments = [];
+    while (!(await fileAdapter.exists(cursor))) {
+        const parent = pathAdapter.dirname(cursor);
+        if (parent === cursor)
+            break;
+        pendingSegments.unshift(pathAdapter.basename(cursor));
+        cursor = parent;
+    }
+    const canonicalExisting = await fileAdapter.realpath(cursor).catch(() => cursor);
+    return pendingSegments.reduce((acc, segment) => pathAdapter.join(acc, segment), canonicalExisting);
+}
+async function ensureAllowedRootsAccessible(roots, fileAdapter) {
+    for (const root of roots) {
+        if (!(await fileAdapter.exists(root))) {
+            try {
+                await fileAdapter.mkdir(root);
+            }
+            catch (error) {
+                throw new ConfigError('CONFIG_CONTEXT_CACHE_ROOT_UNAVAILABLE', {
+                    root,
+                    reason: 'missing',
+                    detail: error instanceof Error ? error.message : String(error ?? 'unknown'),
+                });
+            }
+        }
+        try {
+            await fileAdapter.access(root);
+        }
+        catch (error) {
+            throw new ConfigError('CONFIG_CONTEXT_CACHE_ROOT_UNAVAILABLE', {
+                root,
+                reason: 'not_writable',
+                detail: error instanceof Error ? error.message : String(error ?? 'unknown'),
+            });
+        }
+    }
+}
+//# sourceMappingURL=path-resolver.js.map