salmon-loop 0.2.3

package/dist/core/context/assembly/default-prompt-assembler.js

@@ -0,0 +1,7 @@
+import { formatContextForPrompt } from '../../llm/utils.js';
+export class DefaultPromptAssembler {
+    assemble(context, _req) {
+        return { prompt: formatContextForPrompt(context, { format: 'json' }) };
+    }
+}
+//# sourceMappingURL=default-prompt-assembler.js.map

package/dist/core/context/assembly/prompt-assembler.js

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

package/dist/core/context/ast/import-extractor.js

@@ -0,0 +1,28 @@
+export function extractImportSpecifiers(sourceCode) {
+    const matches = [];
+    const collect = (re) => {
+        for (const match of sourceCode.matchAll(re)) {
+            const value = (match[1] ?? '').trim();
+            if (!value)
+                continue;
+            matches.push({ index: match.index ?? 0, value });
+        }
+    };
+    // ESM: import ... from 'x'; / import 'x';
+    collect(/\bimport\s+(?:type\s+)?(?:[^'"]+?\s+from\s+)?['"]([^'"]+)['"]/g);
+    // CJS: require('x')
+    collect(/\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g);
+    // Dynamic: import('x')
+    collect(/\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g);
+    matches.sort((a, b) => a.index - b.index);
+    const out = [];
+    const seen = new Set();
+    for (const m of matches) {
+        if (seen.has(m.value))
+            continue;
+        seen.add(m.value);
+        out.push(m.value);
+    }
+    return out;
+}
+//# sourceMappingURL=import-extractor.js.map

package/dist/core/context/ast/module-resolver.js

@@ -0,0 +1,61 @@
+import { getPluginRegistry } from '../../plugin/registry.js';
+import { normalizePath, safeDirname, safeJoin } from '../../utils/path.js';
+// Dynamic extension candidates from registered plugins
+function getExtensionCandidates() {
+    const allPlugins = getPluginRegistry().getAll();
+    const extensions = new Set();
+    for (const plugin of allPlugins) {
+        for (const ext of plugin.meta.extensions) {
+            const normalized = ext.startsWith('.') ? ext : `.${ext}`;
+            extensions.add(normalized);
+        }
+    }
+    // Always include .json for config files
+    extensions.add('.json');
+    return Array.from(extensions);
+}
+// Dynamic index candidates from registered plugins
+function getIndexCandidates() {
+    const allPlugins = getPluginRegistry().getAll();
+    const indices = new Set();
+    for (const plugin of allPlugins) {
+        for (const ext of plugin.meta.extensions) {
+            const normalized = ext.startsWith('.') ? ext : `.${ext}`;
+            indices.add(`/index${normalized}`);
+        }
+    }
+    return Array.from(indices);
+}
+export function resolveImportCandidates(opts) {
+    const spec = opts.specifier.trim();
+    if (!spec.startsWith('.'))
+        return [];
+    const baseDir = safeDirname(normalizePath(opts.currentFile));
+    const joined = normalizePath(safeJoin(baseDir, spec));
+    // Prevent escaping the repo root.
+    if (joined.startsWith('..'))
+        return [];
+    const normalizedJoined = joined.replace(/^(\.\/|\/)+/, '');
+    if (!normalizedJoined)
+        return [];
+    const hasExt = /\.[^/.]+$/.test(normalizedJoined);
+    if (hasExt) {
+        const out = [normalizedJoined];
+        if (normalizedJoined.endsWith('.js'))
+            out.push(normalizedJoined.replace(/\.js$/, '.ts'));
+        if (normalizedJoined.endsWith('.jsx'))
+            out.push(normalizedJoined.replace(/\.jsx$/, '.tsx'));
+        return out;
+    }
+    const out = [];
+    const extCandidates = getExtensionCandidates();
+    const idxCandidates = getIndexCandidates();
+    for (const ext of extCandidates) {
+        out.push(`${normalizedJoined}${ext}`);
+    }
+    for (const idx of idxCandidates) {
+        out.push(`${normalizedJoined}${idx}`);
+    }
+    return out;
+}
+//# sourceMappingURL=module-resolver.js.map

package/dist/core/context/ast/source-outline.js

@@ -0,0 +1,25 @@
+const MAX_OUTLINE_LINES = 200;
+export function outlineSource(sourceCode) {
+    const lines = sourceCode.split('\n');
+    const out = [];
+    const include = (line) => {
+        if (out.length >= MAX_OUTLINE_LINES)
+            return;
+        out.push(line);
+    };
+    for (const line of lines) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        if (t.startsWith('import ') || t.startsWith('export ')) {
+            include(line);
+            continue;
+        }
+        if (/^\s*(?:export\s+)?(?:declare\s+)?(interface|type|class|enum|function)\b/.test(line) ||
+            /^\s*(?:export\s+)?(?:const|let|var)\s+[A-Za-z0-9_$]+\s*[:=]/.test(line)) {
+            include(line);
+        }
+    }
+    return out.join('\n').trim();
+}
+//# sourceMappingURL=source-outline.js.map

package/dist/core/context/audit-constants.js

@@ -0,0 +1,23 @@
+export const CONTEXT_AUDIT_ACTION = {
+    inputSummary: 'context.input.summary',
+    cacheLookup: 'context.cache.lookup',
+    keywordsExtracted: 'context.keywords.extracted',
+    gatherCompleted: 'context.gather.completed',
+    targetingCandidates: 'context.targeting.candidates',
+    targetsResolved: 'context.targets.resolved',
+    budgetPolicyPlan: 'context.budget.policy.plan',
+    relevanceRanking: 'context.relevance.ranking',
+    packSummary: 'context.pack.summary',
+    shrinkSummary: 'context.shrink.summary',
+    promotionCompleted: 'context.promotion.completed',
+    promotionFailed: 'context.promotion.failed',
+};
+export const CONTEXT_AUDIT_PHASE = {
+    primary: 'CONTEXT_PRIMARY',
+    gather: 'CONTEXT_GATHER',
+    targets: 'CONTEXT_TARGETS',
+    promotion: 'CONTEXT_PROMOTION',
+    budget: 'CONTEXT_BUDGET',
+    shrink: 'SHRINK',
+};
+//# sourceMappingURL=audit-constants.js.map

package/dist/core/context/audit.js

@@ -0,0 +1,54 @@
+import { recordAuditEvent } from '../observability/audit-trail.js';
+import { redactByKey, redactSensitiveString } from '../security/redaction.js';
+const DEFAULT_LIMITS = {
+    maxDepth: 4,
+    maxStringChars: 2000,
+    maxArrayItems: 50,
+    maxObjectKeys: 50,
+};
+const TRUNCATED = '[Truncated]';
+const CIRCULAR = '[Circular]';
+function sanitizeValue(value, state, key) {
+    if (value === null || value === undefined)
+        return value;
+    const byKey = redactByKey(key, value);
+    if (byKey.redacted)
+        return byKey.value;
+    if (typeof value === 'string') {
+        const { value: redacted } = redactSensitiveString(value);
+        return redacted.length <= DEFAULT_LIMITS.maxStringChars
+            ? redacted
+            : redacted.slice(0, DEFAULT_LIMITS.maxStringChars);
+    }
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+        return value;
+    }
+    if (typeof value === 'symbol' || typeof value === 'function')
+        return String(value);
+    if (state.depth >= DEFAULT_LIMITS.maxDepth)
+        return TRUNCATED;
+    if (Array.isArray(value)) {
+        const next = value.slice(0, DEFAULT_LIMITS.maxArrayItems);
+        return next.map((v) => sanitizeValue(v, { depth: state.depth + 1, seen: state.seen }));
+    }
+    if (typeof value === 'object') {
+        const obj = value;
+        if (state.seen.has(obj))
+            return CIRCULAR;
+        state.seen.add(obj);
+        const out = {};
+        const keys = Object.keys(obj).slice(0, DEFAULT_LIMITS.maxObjectKeys);
+        for (const k of keys) {
+            out[k] = sanitizeValue(obj[k], { depth: state.depth + 1, seen: state.seen }, k);
+        }
+        return out;
+    }
+    return TRUNCATED;
+}
+export function sanitizeAuditDetails(details) {
+    return sanitizeValue(details, { depth: 0, seen: new WeakSet() });
+}
+export function recordContextAuditEvent(action, details, meta) {
+    recordAuditEvent(action, sanitizeAuditDetails(details), meta);
+}
+//# sourceMappingURL=audit.js.map

package/dist/core/context/budget/dynamic-adjuster.js

@@ -0,0 +1,149 @@
+/**
+ * Dynamic Budget Adjuster
+ *
+ * Collects runtime metrics and adjusts budget based on actual usage patterns.
+ */
+/**
+ * Budget adjustment strategy based on runtime feedback.
+ */
+export class DynamicBudgetAdjuster {
+    history = [];
+    maxHistory = 10;
+    adjustmentCount = 0;
+    alertCount = 0;
+    // Adjustment parameters
+    minBudget;
+    maxBudget;
+    adjustmentStep;
+    alertTruncationRateWarn;
+    alertCriticalDropRateWarn;
+    constructor(config) {
+        this.minBudget = config?.minBudget ?? 5000;
+        this.maxBudget = config?.maxBudget ?? 100000;
+        this.adjustmentStep = config?.adjustmentStep ?? 0.15;
+        this.alertTruncationRateWarn = config?.alerts?.truncationRateWarn ?? 0.6;
+        this.alertCriticalDropRateWarn = config?.alerts?.criticalDropRateWarn ?? 0;
+    }
+    /**
+     * Record metrics from a completed iteration.
+     */
+    recordMetrics(metrics) {
+        this.history.push(metrics);
+        if (this.history.length > this.maxHistory) {
+            this.history.shift();
+        }
+    }
+    /**
+     * Calculate recommended budget adjustment.
+     */
+    calculateAdjustment(currentBudget) {
+        if (this.history.length < 2) {
+            return null; // Need at least 2 data points
+        }
+        const recent = this.history.slice(-3); // Last 3 iterations
+        const latest = recent[recent.length - 1];
+        // Strategy 1: Critical content dropped + failure → Increase urgently
+        if (latest.criticalContentDropped && !latest.verifySuccess) {
+            const newBudget = Math.min(currentBudget * (1 + this.adjustmentStep * 2), this.maxBudget);
+            return {
+                newBudget: Math.round(newBudget),
+                reason: 'Critical content dropped and verification failed',
+                confidence: 0.9,
+            };
+        }
+        // Strategy 2: High truncation + low success rate → Increase
+        const truncationRate = recent.filter((m) => m.wasTruncated).length / recent.length;
+        const successRate = recent.filter((m) => m.verifySuccess).length / recent.length;
+        if (truncationRate > 0.6 && successRate < 0.5) {
+            const newBudget = Math.min(currentBudget * (1 + this.adjustmentStep), this.maxBudget);
+            return {
+                newBudget: Math.round(newBudget),
+                reason: `High truncation (${(truncationRate * 100).toFixed(0)}%) and low success (${(successRate * 100).toFixed(0)}%)`,
+                confidence: 0.7,
+            };
+        }
+        // Strategy 3: Low utilization + high success → Decrease
+        const avgUtilization = recent.reduce((sum, m) => sum + m.tokensUsed / m.budgetAllocated, 0) / recent.length;
+        if (avgUtilization < 0.6 && successRate > 0.8 && !latest.wasTruncated) {
+            const newBudget = Math.max(currentBudget * (1 - this.adjustmentStep * 0.5), this.minBudget);
+            return {
+                newBudget: Math.round(newBudget),
+                reason: `Low utilization (${(avgUtilization * 100).toFixed(0)}%) with high success`,
+                confidence: 0.6,
+            };
+        }
+        // Strategy 4: Stable and successful → No change
+        if (successRate > 0.7 && truncationRate < 0.3) {
+            return null; // Current budget is working well
+        }
+        return null;
+    }
+    /**
+     * Get current statistics.
+     */
+    getStats() {
+        if (this.history.length === 0) {
+            return null;
+        }
+        const recent = this.history.slice(-5);
+        return {
+            avgUtilization: recent.reduce((sum, m) => sum + m.tokensUsed / m.budgetAllocated, 0) / recent.length,
+            truncationRate: recent.filter((m) => m.wasTruncated).length / recent.length,
+            successRate: recent.filter((m) => m.verifySuccess).length / recent.length,
+            criticalDropRate: recent.filter((m) => m.criticalContentDropped).length / recent.length,
+            sampleSize: recent.length,
+        };
+    }
+    /**
+     * Reset history (e.g., when starting a new session).
+     */
+    reset() {
+        this.history = [];
+        this.adjustmentCount = 0;
+        this.alertCount = 0;
+    }
+    getAlertThresholds() {
+        return {
+            truncationRateWarn: this.alertTruncationRateWarn,
+            criticalDropRateWarn: this.alertCriticalDropRateWarn,
+        };
+    }
+    recordAdjustment() {
+        this.adjustmentCount += 1;
+    }
+    recordAlert() {
+        this.alertCount += 1;
+    }
+    getRunSummary() {
+        if (this.history.length === 0)
+            return null;
+        const attemptCount = this.history.length;
+        const criticalDropCount = this.history.filter((m) => m.criticalContentDropped).length;
+        const truncationCount = this.history.filter((m) => m.wasTruncated).length;
+        const successCount = this.history.filter((m) => m.verifySuccess).length;
+        const avgUtilization = this.history.reduce((sum, m) => sum + m.tokensUsed / m.budgetAllocated, 0) / attemptCount;
+        return {
+            attemptCount,
+            adjustmentCount: this.adjustmentCount,
+            alertCount: this.alertCount,
+            criticalDropCount,
+            avgUtilization,
+            truncationRate: truncationCount / attemptCount,
+            successRate: successCount / attemptCount,
+        };
+    }
+}
+/**
+ * Global adjuster instance (per session).
+ */
+let globalAdjuster = null;
+export function getGlobalAdjuster(config) {
+    if (!globalAdjuster) {
+        globalAdjuster = new DynamicBudgetAdjuster(config);
+    }
+    return globalAdjuster;
+}
+export function resetGlobalAdjuster() {
+    globalAdjuster = null;
+}
+//# sourceMappingURL=dynamic-adjuster.js.map

package/dist/core/context/budget/example-integration.js

@@ -0,0 +1,49 @@
+/**
+ * Example: How to integrate dynamic budget adjustment into the execution loop.
+ *
+ * This is a reference implementation showing where to hook in the adjuster.
+ */
+import { getGlobalAdjuster } from './dynamic-adjuster.js';
+import { applyBudgetAdjustment, collectBudgetMetrics } from './integration.js';
+/**
+ * Example loop iteration with dynamic budget adjustment.
+ */
+export async function exampleLoopIteration(params) {
+    const { iteration, currentBudget, buildContext, verify } = params;
+    // 1. Build context with current budget
+    const contextResult = await buildContext(currentBudget);
+    // 2. Execute and verify
+    const verifyResult = await verify();
+    // 3. Collect metrics
+    const metrics = collectBudgetMetrics({
+        contextResult,
+        verifyResult,
+        iteration,
+    });
+    // 4. Record metrics for future adjustments
+    getGlobalAdjuster().recordMetrics(metrics);
+    // 5. Calculate adjustment for next iteration
+    const adjustment = applyBudgetAdjustment(currentBudget);
+    if (adjustment) {
+        return {
+            newBudget: adjustment.newBudget,
+            adjustmentReason: adjustment.reason,
+        };
+    }
+    return { newBudget: currentBudget };
+}
+/**
+ * Integration points in the actual loop:
+ *
+ * 1. After context build (in context-budget.ts):
+ *    - Collect metrics from ContextResult
+ *
+ * 2. After verification (in loop iteration):
+ *    - Record verification result
+ *    - Calculate adjustment
+ *
+ * 3. Before next iteration:
+ *    - Apply new budget if recommended
+ *    - Emit adjustment event for observability
+ */
+//# sourceMappingURL=example-integration.js.map

package/dist/core/context/budget/integration.js

@@ -0,0 +1,93 @@
+/**
+ * Budget adjustment integration for execution loop.
+ *
+ * Hooks into the loop to collect metrics and apply adjustments.
+ */
+import { getGlobalAdjuster } from './dynamic-adjuster.js';
+/**
+ * Collect budget metrics after context build and verification.
+ */
+export function collectBudgetMetrics(params) {
+    const { contextResult, verifyResult, iteration } = params;
+    const meta = contextResult.meta;
+    const budgetAllocated = meta.requestedBudgetChars ?? 30000;
+    // Note: usedChars is treated as equivalent to tokens for budget metrics
+    const tokensUsed = meta.usedChars ?? 0;
+    const wasTruncated = meta.truncated ?? false;
+    // Check if critical content was dropped
+    const criticalContentDropped = Boolean(meta.droppedSections &&
+        (meta.droppedSections.stagedDiff ||
+            meta.droppedSections.unstagedDiff ||
+            meta.droppedSections.gitDiff));
+    const verifySuccess = verifyResult?.ok ?? false;
+    return {
+        budgetAllocated,
+        tokensUsed,
+        wasTruncated,
+        criticalContentDropped,
+        verifySuccess,
+        iteration,
+    };
+}
+/**
+ * Apply budget adjustment if recommended.
+ * Returns new budget or null if no adjustment needed.
+ */
+export function applyBudgetAdjustment(currentBudget) {
+    const adjuster = getGlobalAdjuster();
+    const adjustment = adjuster.calculateAdjustment(currentBudget);
+    if (!adjustment) {
+        return null;
+    }
+    // Only apply if confidence is high enough
+    if (adjustment.confidence < 0.5) {
+        return null;
+    }
+    adjuster.recordAdjustment();
+    return {
+        newBudget: adjustment.newBudget,
+        reason: adjustment.reason,
+    };
+}
+/**
+ * Get current budget statistics for observability.
+ */
+export function getBudgetStats() {
+    return getGlobalAdjuster().getStats();
+}
+/**
+ * Evaluate whether budget behavior requires an operator-visible alert.
+ */
+export function evaluateBudgetAlert(stats, thresholds) {
+    if (!stats || stats.sampleSize < 2) {
+        return null;
+    }
+    const effectiveThresholds = {
+        truncationRateWarn: thresholds?.truncationRateWarn ?? 0.6,
+        criticalDropRateWarn: thresholds?.criticalDropRateWarn ?? 0,
+    };
+    if (stats.criticalDropRate > effectiveThresholds.criticalDropRateWarn) {
+        return {
+            level: 'warn',
+            reason: `critical content dropped (${(stats.criticalDropRate * 100).toFixed(0)}%)`,
+        };
+    }
+    if (stats.truncationRate > effectiveThresholds.truncationRateWarn) {
+        return {
+            level: 'warn',
+            reason: `high truncation rate (${(stats.truncationRate * 100).toFixed(0)}%)`,
+        };
+    }
+    return null;
+}
+export function recordBudgetAlert() {
+    getGlobalAdjuster().recordAlert();
+}
+export function recordBudgetAdjustment() {
+    getGlobalAdjuster().recordAdjustment();
+}
+export function getBudgetRunSummary() {
+    return getGlobalAdjuster().getRunSummary();
+}
+export { getGlobalAdjuster };
+//# sourceMappingURL=integration.js.map