salmon-loop 0.2.3

package/dist/core/context/compression/whitespace.js

@@ -0,0 +1,26 @@
+export function normalizeWhitespace(input, options = {}) {
+    const maxConsecutiveBlankLines = options.maxConsecutiveBlankLines ?? 1;
+    const trimFinalNewline = options.trimFinalNewline ?? true;
+    const normalizedNewlines = input.replace(/\r\n/g, '\n');
+    const lines = normalizedNewlines.split('\n').map((l) => l.replace(/[ \t]+$/g, ''));
+    const out = [];
+    let blankRun = 0;
+    for (const line of lines) {
+        const isBlank = line.trim().length === 0;
+        if (isBlank) {
+            blankRun++;
+            if (blankRun <= maxConsecutiveBlankLines)
+                out.push('');
+            continue;
+        }
+        blankRun = 0;
+        out.push(line);
+    }
+    let result = out.join('\n');
+    result = result.replace(/^\n+/, '').replace(/\n+$/, '');
+    if (!trimFinalNewline) {
+        result += '\n';
+    }
+    return result;
+}
+//# sourceMappingURL=whitespace.js.map

package/dist/core/context/dependencies.js

@@ -0,0 +1,102 @@
+import { text } from '../../locales/index.js';
+import { FileAdapter } from '../adapters/fs/file-adapter.js';
+import { LIMITS } from '../config/limits.js';
+import { getLogger } from '../observability/logger.js';
+import { getPluginRegistry } from '../plugin/registry.js';
+import { safeJoin, safeDirname } from '../utils/path.js';
+/**
+ * Simple dependency analyzer to find related files
+ */
+export async function findFileDependencies(filePath, repoPath, options, deps) {
+    const depth = Math.max(1, Math.min(LIMITS.maxDependencyDepth, options?.depth ?? 1));
+    const maxFiles = Math.max(1, options?.maxFiles ?? 1000);
+    const results = [];
+    const seen = new Set();
+    let frontier = [filePath];
+    // Pre-load plugins if not already loaded (though they should be by preflight)
+    // For safety in unit tests that might skip preflight:
+    // await PluginLoader.loadPlugins(); // Ideally this is done at app start
+    for (let d = 0; d < depth; d++) {
+        const nextFrontier = [];
+        for (const current of frontier) {
+            if (results.length >= maxFiles)
+                return results;
+            const directDeps = await findDirectDependencies(current, repoPath, deps?.fileAdapter);
+            for (const dep of directDeps) {
+                if (results.length >= maxFiles)
+                    break;
+                if (seen.has(dep))
+                    continue;
+                seen.add(dep);
+                results.push(dep);
+                nextFrontier.push(dep);
+            }
+        }
+        frontier = nextFrontier;
+        if (frontier.length === 0)
+            break;
+    }
+    return results;
+}
+async function findDirectDependencies(filePath, repoPath, fsAdapter) {
+    try {
+        const content = await (fsAdapter ?? new FileAdapter()).readFile(safeJoin(repoPath, filePath), 'utf-8');
+        const dependencies = [];
+        // Detect language plugin for this file
+        const plugin = getPluginRegistry().getByExtension(filePath);
+        if (plugin) {
+            // Use plugin strategy
+            const rawImports = plugin.dependency.extractImports(content);
+            for (const rawImport of rawImports) {
+                // Resolve path
+                let resolvedDep = rawImport;
+                if (plugin.dependency.resolvePath) {
+                    const result = plugin.dependency.resolvePath(safeDirname(filePath), rawImport);
+                    if (result) {
+                        resolvedDep = result;
+                    }
+                }
+                else {
+                    // Default fallback resolution if plugin doesn't specify
+                    // (This might need improvement for generic support)
+                    resolvedDep = rawImport;
+                }
+                // Construct absolute path
+                // Assumptions: rawImport is relative.
+                // If plugin handles resolution fully, we might need to adjust.
+                // For now, assuming plugin.resolvePath returns a relative path with extension
+                const absoluteDepPath = safeJoin(safeDirname(filePath), resolvedDep);
+                dependencies.push(absoluteDepPath);
+            }
+        }
+        else {
+            // Fallback for unknown languages? Or just return empty.
+            // For now, empty.
+        }
+        return dependencies;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Check dependency versions against expected values
+ */
+export async function verifyDependencyVersion(rootPath, deps) {
+    try {
+        // Read package.json
+        const packageJsonPath = safeJoin(rootPath, 'package.json');
+        const packageJson = JSON.parse(await (deps?.fileAdapter ?? new FileAdapter()).readFile(packageJsonPath, 'utf-8'));
+        // Check web-tree-sitter version
+        const expectedVersion = '0.26.3';
+        const actualVersion = packageJson.dependencies?.['web-tree-sitter'];
+        if (actualVersion !== expectedVersion) {
+            getLogger().warn(text.dependency.versionMismatch('web-tree-sitter', expectedVersion, actualVersion));
+            getLogger().warn(text.dependency.versionMismatchHint);
+        }
+    }
+    catch (error) {
+        getLogger().error(`${text.dependency.checkFailed}: ${error}`);
+    }
+}
+//# sourceMappingURL=dependencies.js.map

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

@@ -0,0 +1,25 @@
+/**
+ * Context effectiveness module.
+ *
+ * Provides tracking and metrics for context quality.
+ *
+ * @example
+ * ```typescript
+ * import { ContextEffectivenessTracker, getEffectivenessTracker } from './effectiveness/index.js';
+ *
+ * const tracker = getEffectivenessTracker();
+ *
+ * // Record usage
+ * tracker.recordUsage('src/file.ts', true, 500, 85);
+ *
+ * // Get metrics
+ * const metrics = tracker.getMetrics();
+ * console.log(`Usage rate: ${metrics.avgUsageRate}`);
+ *
+ * // Get recommendations
+ * const recommendations = tracker.getRecommendations();
+ * ```
+ */
+export { ContextEffectivenessTracker, getEffectivenessTracker, resetEffectivenessTracker, } from './tracker.js';
+export { DEFAULT_EFFECTIVENESS_CONFIG } from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/core/context/effectiveness/tracker.js

@@ -0,0 +1,253 @@
+/**
+ * Context effectiveness tracker.
+ *
+ * Tracks which context files are actually used by the LLM,
+ * identifies missing context patterns, and calculates efficiency metrics.
+ */
+import { DEFAULT_EFFECTIVENESS_CONFIG } from './types.js';
+/**
+ * Context effectiveness tracker.
+ *
+ * Provides insights into context quality:
+ * - Which files are actually useful
+ * - What context is frequently missing
+ * - Token efficiency trends
+ */
+export class ContextEffectivenessTracker {
+    config;
+    usageRecords = [];
+    failureRecords = [];
+    totalTokensUsed = 0;
+    successfulExecutions = 0;
+    totalExecutions = 0;
+    sessionCount = 0;
+    constructor(config = DEFAULT_EFFECTIVENESS_CONFIG) {
+        this.config = config;
+    }
+    /**
+     * Record context usage for a file.
+     */
+    recordUsage(filePath, referenced, tokens, relevanceScore) {
+        if (!this.config.enabled)
+            return;
+        if (Math.random() > this.config.sampleRate)
+            return;
+        // Enforce max records limit
+        if (this.usageRecords.length >= this.config.maxRecords) {
+            this.usageRecords.shift();
+        }
+        this.usageRecords.push({
+            filePath,
+            referenced,
+            tokens,
+            relevanceScore,
+            timestamp: Date.now(),
+        });
+        if (referenced) {
+            this.totalTokensUsed += tokens;
+        }
+    }
+    /**
+     * Record context failure.
+     */
+    recordFailure(type, description, affectedFiles, suggestedFiles) {
+        if (!this.config.enabled)
+            return;
+        if (this.failureRecords.length >= this.config.maxRecords) {
+            this.failureRecords.shift();
+        }
+        this.failureRecords.push({
+            type,
+            description,
+            affectedFiles,
+            suggestedFiles,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Record execution result.
+     */
+    recordExecution(success, tokensUsed) {
+        this.totalExecutions++;
+        if (success) {
+            this.successfulExecutions++;
+        }
+        this.totalTokensUsed += tokensUsed;
+    }
+    /**
+     * Start a new session.
+     */
+    startSession() {
+        this.sessionCount++;
+    }
+    /**
+     * Get context metrics.
+     */
+    getMetrics() {
+        const fileStats = this.aggregateFileStats();
+        // Calculate usage rate
+        const totalFiles = this.usageRecords.length;
+        const referencedFiles = this.usageRecords.filter((r) => r.referenced).length;
+        const avgUsageRate = totalFiles > 0 ? referencedFiles / totalFiles : 0;
+        // Find low usage files
+        const lowUsageFiles = Object.entries(fileStats)
+            .filter(([, stats]) => stats.usageRate < 0.2)
+            .map(([path]) => path);
+        // Find top referenced files
+        const topReferencedFiles = Object.entries(fileStats)
+            .filter(([, stats]) => stats.timesReferenced >= 3)
+            .sort((a, b) => b[1].timesReferenced - a[1].timesReferenced)
+            .slice(0, 10)
+            .map(([path]) => path);
+        // Find common missing context patterns
+        const missingContextPatterns = this.extractMissingContextPatterns();
+        // Calculate token efficiency
+        const tokenEfficiency = this.totalTokensUsed > 0 ? this.successfulExecutions / (this.totalTokensUsed / 1000) : 0;
+        // Failure breakdown
+        const failureBreakdown = {};
+        for (const failure of this.failureRecords) {
+            failureBreakdown[failure.type] = (failureBreakdown[failure.type] || 0) + 1;
+        }
+        return {
+            avgUsageRate,
+            lowUsageFiles,
+            topReferencedFiles,
+            commonMissingContext: missingContextPatterns,
+            tokenEfficiency,
+            totalSessions: this.sessionCount,
+            totalFiles,
+            avgTokensPerSession: this.sessionCount > 0 ? this.totalTokensUsed / this.sessionCount : 0,
+            failureBreakdown,
+        };
+    }
+    /**
+     * Get file effectiveness summary.
+     */
+    getFileEffectiveness(filePath) {
+        const records = this.usageRecords.filter((r) => r.filePath === filePath);
+        if (records.length === 0)
+            return null;
+        const timesIncluded = records.length;
+        const timesReferenced = records.filter((r) => r.referenced).length;
+        const totalTokens = records.reduce((sum, r) => sum + r.tokens, 0);
+        const totalRelevance = records.reduce((sum, r) => sum + r.relevanceScore, 0);
+        return {
+            path: filePath,
+            timesIncluded,
+            timesReferenced,
+            usageRate: timesIncluded > 0 ? timesReferenced / timesIncluded : 0,
+            avgRelevanceScore: timesIncluded > 0 ? totalRelevance / timesIncluded : 0,
+            avgTokens: timesIncluded > 0 ? totalTokens / timesIncluded : 0,
+        };
+    }
+    /**
+     * Get recommendations for context improvement.
+     */
+    getRecommendations() {
+        const recommendations = [];
+        const metrics = this.getMetrics();
+        // Low usage rate recommendation
+        if (metrics.avgUsageRate < 0.3) {
+            recommendations.push(`Low context usage rate (${(metrics.avgUsageRate * 100).toFixed(1)}%). Consider more targeted context gathering.`);
+        }
+        // Common missing context
+        if (metrics.commonMissingContext.length > 0) {
+            recommendations.push(`Frequently missing context: ${metrics.commonMissingContext.slice(0, 3).join(', ')}`);
+        }
+        // Token efficiency
+        if (metrics.tokenEfficiency < 0.5) {
+            recommendations.push('Low token efficiency. Consider refining relevance scoring or context budget.');
+        }
+        // Failure patterns
+        const missingContextFailures = metrics.failureBreakdown['missing_context'] || 0;
+        if (missingContextFailures > 3) {
+            recommendations.push('High rate of missing context failures. Review import resolution and dependency tracking.');
+        }
+        return recommendations;
+    }
+    /**
+     * Reset tracking data.
+     */
+    reset() {
+        this.usageRecords = [];
+        this.failureRecords = [];
+        this.totalTokensUsed = 0;
+        this.successfulExecutions = 0;
+        this.totalExecutions = 0;
+        this.sessionCount = 0;
+    }
+    /**
+     * Aggregate file statistics.
+     */
+    aggregateFileStats() {
+        const stats = new Map();
+        for (const record of this.usageRecords) {
+            const existing = stats.get(record.filePath);
+            if (existing) {
+                existing.timesIncluded++;
+                if (record.referenced)
+                    existing.timesReferenced++;
+                existing.avgRelevanceScore = (existing.avgRelevanceScore + record.relevanceScore) / 2;
+                existing.avgTokens = (existing.avgTokens + record.tokens) / 2;
+            }
+            else {
+                stats.set(record.filePath, {
+                    path: record.filePath,
+                    timesIncluded: 1,
+                    timesReferenced: record.referenced ? 1 : 0,
+                    usageRate: record.referenced ? 1 : 0,
+                    avgRelevanceScore: record.relevanceScore,
+                    avgTokens: record.tokens,
+                });
+            }
+        }
+        // Recalculate usage rates
+        for (const summary of stats.values()) {
+            summary.usageRate =
+                summary.timesIncluded > 0 ? summary.timesReferenced / summary.timesIncluded : 0;
+        }
+        return stats;
+    }
+    /**
+     * Extract missing context patterns from failure records.
+     */
+    extractMissingContextPatterns() {
+        const patterns = [];
+        const missingContextFailures = this.failureRecords.filter((f) => f.type === 'missing_context');
+        // Extract suggested files
+        for (const failure of missingContextFailures) {
+            if (failure.suggestedFiles) {
+                patterns.push(...failure.suggestedFiles);
+            }
+        }
+        // Return unique patterns, most common first
+        const patternCounts = new Map();
+        for (const pattern of patterns) {
+            patternCounts.set(pattern, (patternCounts.get(pattern) || 0) + 1);
+        }
+        return Array.from(patternCounts.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([pattern]) => pattern);
+    }
+}
+/**
+ * Global effectiveness tracker instance.
+ */
+let globalInstance = null;
+/**
+ * Get global effectiveness tracker.
+ */
+export function getEffectivenessTracker() {
+    if (!globalInstance) {
+        globalInstance = new ContextEffectivenessTracker();
+    }
+    return globalInstance;
+}
+/**
+ * Reset global instance (for testing).
+ */
+export function resetEffectivenessTracker() {
+    globalInstance = null;
+}
+//# sourceMappingURL=tracker.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * Context effectiveness types and interfaces.
+ *
+ * Tracks context usage, quality metrics, and failure attribution.
+ */
+/**
+ * Default effectiveness config.
+ */
+export const DEFAULT_EFFECTIVENESS_CONFIG = {
+    enabled: true,
+    maxRecords: 1000,
+    usefulnessThreshold: 20,
+    sampleRate: 1.0,
+};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * 上下文格式化器导出
+ */
+export { ContextFormatConverter } from './json-converter.js';
+// 保持向后兼容性 - 重新导出 XML 格式化器
+export { formatContextForXmlPrompt } from './xml-context.js';
+//# sourceMappingURL=index.js.map