salmon-loop 0.2.3

package/dist/core/context/policies/pack-until-full.js

@@ -0,0 +1,419 @@
+/**
+ * Pack-Until-Full budget policy.
+ *
+ * Packs context items by priority until budget is exhausted.
+ * Supports both character-based (legacy) and token-based (accurate) budgeting.
+ */
+import { text } from '../../../locales/index.js';
+import { LIMITS } from '../../config/limits.js';
+import { normalizePath } from '../../utils/path.js';
+import { TokenBudgetCalculator } from '../token/token-budget.js';
+/**
+ * Character-based budget calculator (legacy).
+ */
+class CharBudgetCalculator {
+    count(text) {
+        return text.length;
+    }
+    calculateTotalTokens(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;
+    }
+    calculateDiffTokens(context) {
+        return ((context.gitDiff?.length ?? 0) +
+            (context.stagedDiff?.length ?? 0) +
+            (context.unstagedDiff?.length ?? 0) +
+            (context.untrackedDiff?.length ?? 0));
+    }
+    calculateFileTokens(file) {
+        return file.content?.length ?? 0;
+    }
+    calculateSnippetTokens(snippet) {
+        return snippet.content?.length ?? 0;
+    }
+    getDefaultBudget() {
+        return LIMITS.maxContextChars;
+    }
+    getMinBudget() {
+        return LIMITS.minContextChars;
+    }
+}
+/**
+ * Adapter for TokenBudgetCalculator.
+ */
+class TokenBudgetAdapter {
+    calculator;
+    constructor(calculator) {
+        this.calculator = calculator;
+    }
+    count(text) {
+        return this.calculator.count(text);
+    }
+    calculateTotalTokens(context) {
+        return this.calculator.calculateTotalTokens(context);
+    }
+    calculateDiffTokens(context) {
+        return this.calculator.calculateDiffTokens(context);
+    }
+    calculateFileTokens(file) {
+        return this.calculator.calculateFileTokens(file);
+    }
+    calculateSnippetTokens(snippet) {
+        return this.calculator.calculateSnippetTokens(snippet);
+    }
+    getDefaultBudget() {
+        return this.calculator.getDefaultBudget();
+    }
+    getMinBudget() {
+        return this.calculator.getMinBudget();
+    }
+}
+/**
+ * Create budget calculator based on mode.
+ */
+export function createBudgetCalculator(tokenCalculator) {
+    if (tokenCalculator) {
+        return new TokenBudgetAdapter(tokenCalculator);
+    }
+    return new CharBudgetCalculator();
+}
+/**
+ * Budget allocation strategy with partitioned quotas.
+ * Ensures critical content always has guaranteed space.
+ */
+function truncateWithMarker(content, maxUnits, minUnits, calculator) {
+    if (maxUnits < minUnits)
+        return undefined;
+    const contentUnits = calculator.count(content);
+    if (contentUnits <= maxUnits)
+        return content;
+    const marker = `\n${text.context.contentTruncated}\n`;
+    const markerUnits = calculator.count(marker);
+    const maxSliceUnits = Math.max(0, maxUnits - markerUnits);
+    if (maxSliceUnits < minUnits) {
+        // Simple truncation without marker
+        const ratio = maxUnits / contentUnits;
+        const sliceLen = Math.floor(content.length * ratio);
+        return content.substring(0, sliceLen);
+    }
+    const ratio = maxSliceUnits / contentUnits;
+    const sliceLen = Math.floor(content.length * ratio);
+    return `${content.substring(0, sliceLen)}${marker}`;
+}
+function buildTargetSet(context) {
+    const set = new Set();
+    for (const t of context.targets ?? []) {
+        const key = normalizePath(t.path).replace(/^(\.\/|\/)+/, '');
+        if (key)
+            set.add(key);
+    }
+    if (context.primaryFile) {
+        const key = normalizePath(context.primaryFile).replace(/^(\.\/|\/)+/, '');
+        if (key)
+            set.add(key);
+    }
+    return set;
+}
+/**
+ * Singleton token calculator for default usage.
+ * Initialized lazily on first use.
+ */
+let defaultTokenCalculator = null;
+let initializationPromise = null;
+let useTokenBudget = true; // Default to true
+/**
+ * Set whether to use token budget by default.
+ * Can be controlled via config.context.useTokenBudget.
+ */
+export function setUseTokenBudget(enabled) {
+    useTokenBudget = enabled;
+}
+/**
+ * Set model for adaptive budget calculation.
+ * This updates budget limits based on model capabilities.
+ */
+export function setDefaultModel(modelId) {
+    if (defaultTokenCalculator) {
+        defaultTokenCalculator.setModel(modelId);
+    }
+}
+/**
+ * Get or create the default token calculator.
+ * Initializes on first call.
+ */
+async function getDefaultTokenCalculator() {
+    if (defaultTokenCalculator) {
+        return defaultTokenCalculator;
+    }
+    if (!initializationPromise) {
+        initializationPromise = (async () => {
+            defaultTokenCalculator = new TokenBudgetCalculator();
+            await defaultTokenCalculator.initialize();
+        })();
+    }
+    await initializationPromise;
+    return defaultTokenCalculator;
+}
+/**
+ * Create default budget calculator.
+ * Uses token-based calculation by default for accuracy.
+ * Falls back to char-based if token calculator initialization fails or disabled.
+ */
+function createDefaultCalculator() {
+    // If token budget is disabled, use char calculator
+    if (!useTokenBudget) {
+        return new CharBudgetCalculator();
+    }
+    // Return a lazy-initializing adapter
+    return {
+        count(text) {
+            if (defaultTokenCalculator?.mode === 'token') {
+                return defaultTokenCalculator.count(text);
+            }
+            // Fallback to char-based estimation
+            return Math.ceil(text.length / 4);
+        },
+        calculateTotalTokens(context) {
+            if (defaultTokenCalculator?.mode === 'token') {
+                return defaultTokenCalculator.calculateTotalTokens(context);
+            }
+            return new CharBudgetCalculator().calculateTotalTokens(context);
+        },
+        calculateDiffTokens(context) {
+            if (defaultTokenCalculator?.mode === 'token') {
+                return defaultTokenCalculator.calculateDiffTokens(context);
+            }
+            return new CharBudgetCalculator().calculateDiffTokens(context);
+        },
+        calculateFileTokens(file) {
+            if (defaultTokenCalculator?.mode === 'token') {
+                return defaultTokenCalculator.calculateFileTokens(file);
+            }
+            return file.content?.length ?? 0;
+        },
+        calculateSnippetTokens(snippet) {
+            if (defaultTokenCalculator?.mode === 'token') {
+                return defaultTokenCalculator.calculateSnippetTokens(snippet);
+            }
+            return snippet.content?.length ?? 0;
+        },
+        getDefaultBudget() {
+            if (defaultTokenCalculator?.mode === 'token') {
+                return defaultTokenCalculator.getDefaultBudget();
+            }
+            return LIMITS.maxContextChars;
+        },
+        getMinBudget() {
+            if (defaultTokenCalculator?.mode === 'token') {
+                return defaultTokenCalculator.getMinBudget();
+            }
+            return LIMITS.minContextChars;
+        },
+    };
+}
+/**
+ * Initialize the default token calculator.
+ * Call this at application startup for best performance.
+ */
+export async function initializeDefaultCalculator() {
+    await getDefaultTokenCalculator();
+}
+/**
+ * Pack context items until budget is exhausted.
+ *
+ * @param context - Context to pack
+ * @param budget - Budget in tokens/chars (defaults to calculator's default)
+ * @param calculator - Budget calculator (defaults to token-based)
+ */
+export function packUntilFull(context, budget, calculator) {
+    const calc = calculator ?? createDefaultCalculator();
+    const budgetUnits = budget ?? calc.getDefaultBudget();
+    const totalUnits = calc.calculateTotalTokens(context);
+    if (totalUnits <= budgetUnits) {
+        return { context, truncated: false };
+    }
+    const primaryUnits = calc.count(context.primaryText ?? '');
+    const diffUnits = calc.calculateDiffTokens(context);
+    // Calculate minimum guaranteed budgets for critical content
+    // Ensure diffs get at least what they need (up to 30% of budget)
+    const minDiffBudget = diffUnits > 0 ? Math.min(diffUnits, Math.floor(budgetUnits * 0.3)) : 0;
+    const minTargetBudget = Math.floor(budgetUnits * 0.1); // Guarantee 10% for targets
+    const remainingUnits = budgetUnits - primaryUnits;
+    if (remainingUnits <= 0) {
+        const emergencyDiffBudget = diffUnits > 0 ? Math.max(1, Math.min(diffUnits, Math.floor(budgetUnits * 0.1))) : 0;
+        const minDiffUnits = Math.min(calc.count('x'.repeat(16)), Math.max(1, emergencyDiffBudget));
+        let remainingDiffUnits = emergencyDiffBudget;
+        const stagedDiff = context.stagedDiff
+            ? truncateWithMarker(context.stagedDiff, remainingDiffUnits, minDiffUnits, calc)
+            : undefined;
+        if (stagedDiff)
+            remainingDiffUnits = Math.max(0, remainingDiffUnits - calc.count(stagedDiff));
+        const unstagedDiff = context.unstagedDiff
+            ? truncateWithMarker(context.unstagedDiff, remainingDiffUnits, minDiffUnits, calc)
+            : undefined;
+        if (unstagedDiff) {
+            remainingDiffUnits = Math.max(0, remainingDiffUnits - calc.count(unstagedDiff));
+        }
+        const gitDiff = !stagedDiff && !unstagedDiff && context.gitDiff
+            ? truncateWithMarker(context.gitDiff, remainingDiffUnits, minDiffUnits, calc)
+            : undefined;
+        if (gitDiff)
+            remainingDiffUnits = Math.max(0, remainingDiffUnits - calc.count(gitDiff));
+        const untrackedDiff = context.untrackedDiff
+            ? truncateWithMarker(context.untrackedDiff, remainingDiffUnits, minDiffUnits, calc)
+            : undefined;
+        return {
+            context: {
+                ...context,
+                relatedFiles: [],
+                rgSnippets: [],
+                gitDiff,
+                stagedDiff,
+                unstagedDiff,
+                untrackedDiff,
+            },
+            truncated: true,
+        };
+    }
+    // Reserve budget for diffs and targets
+    const reservedForDiff = Math.max(minDiffBudget, 0);
+    const reservedForTargets = Math.max(minTargetBudget, 0);
+    let remainingForContent = Math.max(0, remainingUnits - reservedForDiff - reservedForTargets);
+    const targetSet = buildTargetSet(context);
+    // Respect pre-sorted order from relevance ranking
+    const relatedFiles = context.relatedFiles ?? [];
+    const truncatedRelated = [];
+    let usedTargetBudget = 0;
+    // Pack related files (targets use reserved budget, others use remaining)
+    for (const file of relatedFiles) {
+        const isTarget = targetSet.has(normalizePath(file.path).replace(/^(\.\/|\/)+/, ''));
+        const fileUnits = calc.calculateFileTokens(file);
+        // Determine available budget
+        const availableBudget = isTarget
+            ? Math.max(0, reservedForTargets - usedTargetBudget) + remainingForContent
+            : remainingForContent;
+        if (fileUnits <= availableBudget) {
+            truncatedRelated.push(file);
+            if (isTarget) {
+                const fromTargetReserve = Math.min(fileUnits, Math.max(0, reservedForTargets - usedTargetBudget));
+                usedTargetBudget += fromTargetReserve;
+                remainingForContent -= fileUnits - fromTargetReserve;
+            }
+            else {
+                remainingForContent -= fileUnits;
+            }
+            continue;
+        }
+        const outline = file.outline;
+        const outlineUnits = outline ? calc.count(outline) : 0;
+        const minSnippetUnits = calc.count('x'.repeat(LIMITS.minSnippetChars));
+        if (outline && outlineUnits <= availableBudget && outlineUnits >= minSnippetUnits) {
+            const outlineContent = `${outline}\n\n${text.context.relatedContentTruncated}`;
+            truncatedRelated.push({
+                ...file,
+                mode: 'outline',
+                content: outlineContent,
+                outline: undefined,
+            });
+            const outlineSize = calc.count(outlineContent);
+            if (isTarget) {
+                usedTargetBudget += outlineSize;
+            }
+            else {
+                remainingForContent -= outlineSize;
+            }
+            continue;
+        }
+        // Force include target outline even if over budget
+        if (isTarget && outline && outlineUnits >= minSnippetUnits) {
+            const outlineContent = `${outline}\n\n${text.context.relatedContentTruncated}`;
+            truncatedRelated.push({
+                ...file,
+                mode: 'outline',
+                content: outlineContent,
+                outline: undefined,
+            });
+            continue;
+        }
+        if (availableBudget >= minSnippetUnits) {
+            const ratio = availableBudget / fileUnits;
+            const sliceLen = Math.floor((file.content?.length ?? 0) * ratio);
+            truncatedRelated.push({
+                ...file,
+                mode: 'outline',
+                content: file.content?.substring(0, sliceLen) ?? '',
+                outline: undefined,
+            });
+            if (isTarget) {
+                usedTargetBudget += availableBudget;
+            }
+            else {
+                remainingForContent = 0;
+            }
+        }
+        break;
+    }
+    // Add unused target budget back to content budget
+    remainingForContent += Math.max(0, reservedForTargets - usedTargetBudget);
+    const snippets = context.rgSnippets;
+    const truncatedSnippets = [];
+    for (const snippet of snippets) {
+        const snippetUnits = calc.calculateSnippetTokens(snippet);
+        if (snippetUnits <= remainingForContent) {
+            truncatedSnippets.push(snippet);
+            remainingForContent -= snippetUnits;
+            continue;
+        }
+        const minSnippetUnits = calc.count('x'.repeat(LIMITS.minSnippetChars));
+        if (remainingForContent >= minSnippetUnits) {
+            const ratio = remainingForContent / snippetUnits;
+            const sliceLen = Math.floor((snippet.content?.length ?? 0) * ratio);
+            truncatedSnippets.push({
+                ...snippet,
+                content: snippet.content?.substring(0, sliceLen) ?? '',
+            });
+        }
+        break;
+    }
+    // Pack diffs using reserved budget
+    let remainingDiffUnits = reservedForDiff;
+    // Minimum diff budget - adjust based on available budget
+    const minDiffUnits = Math.min(calc.count('x'.repeat(32)), Math.max(1, remainingDiffUnits));
+    const stagedDiff = context.stagedDiff
+        ? truncateWithMarker(context.stagedDiff, remainingDiffUnits, minDiffUnits, calc)
+        : undefined;
+    if (stagedDiff)
+        remainingDiffUnits = Math.max(0, remainingDiffUnits - calc.count(stagedDiff));
+    const unstagedDiff = context.unstagedDiff
+        ? truncateWithMarker(context.unstagedDiff, remainingDiffUnits, minDiffUnits, calc)
+        : undefined;
+    if (unstagedDiff)
+        remainingDiffUnits = Math.max(0, remainingDiffUnits - calc.count(unstagedDiff));
+    const gitDiff = !stagedDiff && !unstagedDiff && context.gitDiff
+        ? truncateWithMarker(context.gitDiff, remainingDiffUnits, minDiffUnits, calc)
+        : undefined;
+    if (gitDiff)
+        remainingDiffUnits -= calc.count(gitDiff);
+    const untrackedDiff = context.untrackedDiff
+        ? truncateWithMarker(context.untrackedDiff, remainingDiffUnits, minDiffUnits, calc)
+        : undefined;
+    return {
+        context: {
+            ...context,
+            relatedFiles: truncatedRelated,
+            rgSnippets: truncatedSnippets,
+            stagedDiff,
+            unstagedDiff,
+            gitDiff,
+            untrackedDiff,
+        },
+        truncated: true,
+    };
+}
+//# sourceMappingURL=pack-until-full.js.map

package/dist/core/context/scoring/relevance.js

@@ -0,0 +1,191 @@
+import { normalizePath } from '../../utils/path.js';
+function extractChangedFilesFromDiffText(diffText) {
+    const out = new Set();
+    if (!diffText)
+        return out;
+    const re = /^diff --git a\/(.+?) b\/(.+?)$/gm;
+    let match;
+    while ((match = re.exec(diffText)) !== null) {
+        const file = normalizePath(match[2] || match[1] || '').replace(/^(\.\/|\/)+/, '');
+        if (file)
+            out.add(file);
+    }
+    return out;
+}
+function buildTargetSet(context) {
+    const out = new Set();
+    for (const t of context.targets ?? []) {
+        const p = normalizePath(t.path).replace(/^(\.\/|\/)+/, '');
+        if (p)
+            out.add(p);
+    }
+    if (context.primaryFile) {
+        const p = normalizePath(context.primaryFile).replace(/^(\.\/|\/)+/, '');
+        if (p)
+            out.add(p);
+    }
+    return out;
+}
+function extractKeywords(instruction) {
+    if (!instruction)
+        return [];
+    // Basic keyword extraction: split by non-alphanumeric, filter short words
+    return instruction
+        .toLowerCase()
+        .split(/[^a-z0-9_]/)
+        .filter((word) => word.length >= 3);
+}
+/**
+ * Compute a granular relevance score for a related file.
+ */
+function computeRelatedFileScore(params) {
+    const { file, changedFiles, isTarget, repoMap, symbolMap, keywords, primaryFile } = params;
+    const normalizedPath = normalizePath(file.path).replace(/^(\.\/|\/)+/, '');
+    let score = 50;
+    // 1. Kind-based scoring
+    if (file.kind === 'import') {
+        score = changedFiles.has(normalizedPath) ? 90 : 60;
+    }
+    else if (file.kind === 'failed') {
+        score = 95;
+    }
+    else if (file.kind === 'dependency') {
+        score = changedFiles.has(normalizedPath) ? 85 : 55;
+    }
+    // 2. Explicit Target Bonus
+    if (isTarget) {
+        if (file.kind === 'failed') {
+            score = 98;
+        }
+        else {
+            score = Math.min(97, score + 30);
+        }
+    }
+    // 3. RepoMap Depth Penalty
+    if (repoMap) {
+        const node = repoMap.nodes.find((n) => normalizePath(n.path).replace(/^(\.\/|\/)+/, '') === normalizedPath);
+        if (node) {
+            score -= node.depth * 5;
+        }
+        else if (repoMap.nodes.length > 0) {
+            score -= 15;
+        }
+    }
+    // 4. Instruction Keyword Bonus (Path-based)
+    const fileNameLower = normalizedPath.toLowerCase();
+    const pathTokens = fileNameLower.split(/[^a-z0-9]/).filter((t) => t.length >= 3);
+    for (const kw of keywords) {
+        const matchesPath = pathTokens.some((t) => kw.includes(t) || t.includes(kw));
+        if (matchesPath) {
+            score += 15;
+            break;
+        }
+    }
+    // 5. Symbol Analysis
+    if (symbolMap) {
+        const fileSymbols = symbolMap.nodes.filter((n) => n.path && normalizePath(n.path).replace(/^(\.\/|\/)+/, '') === normalizedPath);
+        const hasDefinition = fileSymbols.some((n) => n.kind === 'definition');
+        if (hasDefinition) {
+            score += 10;
+        }
+        // 6. Instruction Keyword Bonus (Symbol-based)
+        for (const kw of keywords) {
+            const matchesSymbol = fileSymbols.some((s) => {
+                const symLower = s.name.toLowerCase();
+                return symLower.includes(kw) || kw.includes(symLower);
+            });
+            if (matchesSymbol) {
+                score += 10;
+                break;
+            }
+        }
+        // 7. Call Density Bonus
+        if (primaryFile) {
+            const normalizedPrimary = normalizePath(primaryFile).replace(/^(\.\/|\/)+/, '');
+            const callCount = symbolMap.edges.filter((e) => {
+                if (e.type !== 'call')
+                    return false;
+                const fromNode = symbolMap.nodes.find((n) => n.id === e.from);
+                const toNode = symbolMap.nodes.find((n) => n.id === e.to);
+                return (fromNode?.path &&
+                    normalizePath(fromNode.path).replace(/^(\.\/|\/)+/, '') === normalizedPrimary &&
+                    toNode?.path &&
+                    normalizePath(toNode.path).replace(/^(\.\/|\/)+/, '') === normalizedPath);
+            }).length;
+            if (callCount > 0) {
+                score += Math.min(15, callCount * 3);
+            }
+        }
+    }
+    return score;
+}
+function stableSortByScore(items, getScore, getTieKey) {
+    return [...items].sort((a, b) => {
+        const sa = getScore(a);
+        const sb = getScore(b);
+        if (sa !== sb)
+            return sb - sa;
+        return getTieKey(a).localeCompare(getTieKey(b));
+    });
+}
+function rankRelatedFiles(related, changedFiles, targetSet, repoMap, symbolMap, keywords, primaryFile) {
+    if (!related)
+        return related;
+    return stableSortByScore(related, (f) => computeRelatedFileScore({
+        file: f,
+        changedFiles,
+        isTarget: targetSet.has(normalizePath(f.path).replace(/^(\.\/|\/)+/, '')),
+        repoMap,
+        symbolMap,
+        keywords,
+        primaryFile,
+    }), (f) => normalizePath(f.path).replace(/^(\.\/|\/)+/, ''));
+}
+function rankSnippets(snippets, targetSet) {
+    if (!snippets || snippets.length === 0)
+        return snippets;
+    const freq = new Map();
+    for (const s of snippets) {
+        const key = normalizePath(s.file).replace(/^(\.\/|\/)+/, '');
+        freq.set(key, (freq.get(key) ?? 0) + 1);
+    }
+    return [...snippets].sort((a, b) => {
+        const aPath = normalizePath(a.file).replace(/^(\.\/|\/)+/, '');
+        const bPath = normalizePath(b.file).replace(/^(\.\/|\/)+/, '');
+        const aIsTarget = targetSet.has(aPath);
+        const bIsTarget = targetSet.has(bPath);
+        if (aIsTarget !== bIsTarget)
+            return aIsTarget ? -1 : 1;
+        const fa = freq.get(aPath) ?? 0;
+        const fb = freq.get(bPath) ?? 0;
+        if (fa !== fb)
+            return fb - fa;
+        if (a.file !== b.file)
+            return a.file.localeCompare(b.file);
+        return a.line - b.line;
+    });
+}
+/**
+ * Ranks context items by relevance to the primary task and instruction.
+ *
+ * This implementation uses a multi-factor scoring engine (Semantic Probe) that considers:
+ * - Direct targets and diffs
+ * - AST symbol density and call frequency
+ * - Instruction keyword alignment
+ * - Dependency graph distance
+ */
+export function rankContextForRelevance(context) {
+    const changed = new Set([
+        ...extractChangedFilesFromDiffText(context.stagedDiff),
+        ...extractChangedFilesFromDiffText(context.unstagedDiff),
+        ...extractChangedFilesFromDiffText(context.gitDiff),
+    ]);
+    const targetSet = buildTargetSet(context);
+    const keywords = extractKeywords(context.instruction);
+    return {
+        ...context,
+        relatedFiles: rankRelatedFiles(context.relatedFiles, changed, targetSet, context.repoMap, context.symbolMap, keywords, context.primaryFile),
+        rgSnippets: rankSnippets(context.rgSnippets, targetSet),
+    };
+}
+//# sourceMappingURL=relevance.js.map

package/dist/core/context/service-deps.js

@@ -0,0 +1,32 @@
+import { DefaultPromptAssembler } from './assembly/default-prompt-assembler.js';
+import { PromptCachingManager } from './cache/prompt-caching.js';
+import { ArchitectureGatherer } from './gatherers/architecture-gatherer.js';
+import { ArtifactGatherer } from './gatherers/artifact-gatherer.js';
+import { AstGatherer } from './gatherers/ast-gatherer.js';
+import { GhostDependencyGatherer } from './gatherers/ghost-dependency-gatherer.js';
+import { GitDiffGatherer } from './gatherers/git-diff-gatherer.js';
+import { GitHistoryGatherer } from './gatherers/git-history-gatherer.js';
+import { KnowledgeGatherer } from './gatherers/knowledge-gatherer.js';
+import { MetadataGatherer } from './gatherers/metadata-gatherer.js';
+import { PrimaryTextGatherer } from './gatherers/primary-text-gatherer.js';
+import { RipgrepGatherer } from './gatherers/ripgrep-gatherer.js';
+import { TargetResolver } from './targeting/target-resolver.js';
+export function defaultContextServiceDeps() {
+    const ripgrepGatherer = new RipgrepGatherer();
+    return {
+        primaryTextGatherer: new PrimaryTextGatherer(),
+        ripgrepGatherer,
+        gitDiffGatherer: new GitDiffGatherer(),
+        astGatherer: new AstGatherer(),
+        metadataGatherer: new MetadataGatherer(),
+        gitHistoryGatherer: new GitHistoryGatherer(),
+        architectureGatherer: new ArchitectureGatherer(),
+        knowledgeGatherer: new KnowledgeGatherer(),
+        artifactGatherer: new ArtifactGatherer(),
+        ghostDependencyGatherer: new GhostDependencyGatherer(ripgrepGatherer),
+        targetResolver: new TargetResolver(),
+        assembler: new DefaultPromptAssembler(),
+        promptCachingManager: new PromptCachingManager(),
+    };
+}
+//# sourceMappingURL=service-deps.js.map

package/dist/core/context/service-helpers.js

@@ -0,0 +1,32 @@
+export function assertNotAborted(signal) {
+    if (signal?.aborted) {
+        throw new Error('Operation cancelled by user');
+    }
+}
+export function calculateUsedChars(context) {
+    const primary = context.primaryText?.length ?? 0;
+    const related = context.relatedFiles?.reduce((sum, f) => sum + (f.content?.length ?? 0), 0) ?? 0;
+    const snippets = context.rgSnippets.reduce((sum, s) => sum + (s.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;
+}
+export function calculateSectionChars(context) {
+    const primary = context.primaryText?.length ?? 0;
+    const relatedFiles = context.relatedFiles?.reduce((sum, f) => sum + (f.content?.length ?? 0), 0) ?? 0;
+    const rgSnippets = context.rgSnippets.reduce((sum, s) => sum + (s.content?.length ?? 0), 0);
+    const diffs = (context.gitDiff?.length ?? 0) +
+        (context.stagedDiff?.length ?? 0) +
+        (context.unstagedDiff?.length ?? 0) +
+        (context.untrackedDiff?.length ?? 0);
+    return {
+        primary,
+        relatedFiles,
+        rgSnippets,
+        diffs,
+        total: primary + relatedFiles + rgSnippets + diffs,
+    };
+}
+//# sourceMappingURL=service-helpers.js.map