salmon-loop 0.2.3

package/dist/core/context/gatherers/metadata-gatherer.js

@@ -0,0 +1,59 @@
+import { FileAdapter } from '../../adapters/fs/file-adapter.js';
+import { safeJoin } from '../../utils/path.js';
+export class MetadataGatherer {
+    fileAdapter = new FileAdapter();
+    async gather(req) {
+        const { repoPath } = req;
+        const metadata = {};
+        // 1. package.json
+        try {
+            const pkgRaw = await this.fileAdapter.readFile(safeJoin(repoPath, 'package.json'), 'utf-8');
+            metadata.packageJson = JSON.parse(pkgRaw);
+        }
+        catch {
+            // Ignored
+        }
+        // 2. README.md (first 1000 chars)
+        try {
+            const readmeRaw = await this.fileAdapter.readFile(safeJoin(repoPath, 'README.md'), 'utf-8');
+            metadata.readmeHeader = readmeRaw.slice(0, 1000);
+        }
+        catch {
+            // Ignored
+        }
+        // 3. AI Instructions (GEMINI.md, CLAUDE.md, ARCH.md)
+        const aiFiles = ['GEMINI.md', 'CLAUDE.md', 'ARCH.md', '.gemini/ARCH.md'];
+        for (const file of aiFiles) {
+            try {
+                const content = await this.fileAdapter.readFile(safeJoin(repoPath, file), 'utf-8');
+                metadata.aiInstructions = (metadata.aiInstructions || '') + `\n--- ${file} ---\n${content}`;
+            }
+            catch {
+                // Ignored
+            }
+        }
+        // 4. List common config files
+        const commonConfigs = [
+            'package.json',
+            'tsconfig.json',
+            'eslint.config.js',
+            '.prettierrc',
+            'vitest.config.ts',
+            'jest.config.js',
+            'bun.lock',
+            'pnpm-lock.yaml',
+        ];
+        metadata.configFiles = [];
+        for (const config of commonConfigs) {
+            try {
+                await this.fileAdapter.readFile(safeJoin(repoPath, config), 'utf-8');
+                metadata.configFiles.push(config);
+            }
+            catch {
+                // Ignored: config not found
+            }
+        }
+        return metadata;
+    }
+}
+//# sourceMappingURL=metadata-gatherer.js.map

package/dist/core/context/gatherers/primary-text-gatherer.js

@@ -0,0 +1,36 @@
+import { text } from '../../../locales/index.js';
+import { FileAdapter } from '../../adapters/fs/file-adapter.js';
+import { defaultPathAdapter } from '../../adapters/path/path-adapter.js';
+import { LIMITS } from '../../config/limits.js';
+import { safeJoin } from '../../utils/path.js';
+export class PrimaryTextGatherer {
+    fileAdapter = new FileAdapter();
+    async gather(req) {
+        let primaryText;
+        if (req.primaryFile) {
+            if (req.snapshotHash && req.checkpointManager) {
+                const snapshotContent = await req.checkpointManager.readSnapshotFile(req.repoPath, req.snapshotHash, req.primaryFile);
+                primaryText = snapshotContent === null ? undefined : snapshotContent;
+                if (primaryText === undefined) {
+                    // Keep legacy error semantics for now to avoid unexpected behavior changes.
+                    throw new Error(`File ${req.primaryFile} not found in snapshot ${req.snapshotHash}. This may happen if the file is ignored and not explicitly included.`);
+                }
+            }
+            else {
+                const filePath = defaultPathAdapter.isAbsolute(req.primaryFile)
+                    ? req.primaryFile
+                    : safeJoin(req.repoPath, req.primaryFile);
+                primaryText = await this.fileAdapter.readFile(filePath, 'utf-8');
+            }
+        }
+        else if (req.selection) {
+            primaryText = req.selection;
+        }
+        if (primaryText && primaryText.length > LIMITS.maxPrimaryChars) {
+            primaryText =
+                primaryText.substring(0, LIMITS.maxPrimaryChars) + `\n${text.context.contentTruncated}`;
+        }
+        return { primaryText };
+    }
+}
+//# sourceMappingURL=primary-text-gatherer.js.map

package/dist/core/context/gatherers/ripgrep-gatherer.js

@@ -0,0 +1,104 @@
+import { LIMITS } from '../../config/limits.js';
+import { getLogger } from '../../observability/logger.js';
+import { spawnCommand } from '../../runtime/process-runner.js';
+import { normalizePath } from '../../utils/path.js';
+export class RipgrepGatherer {
+    async runRipgrep(query, cwd, signal) {
+        getLogger().trace(`  [RG] Searching for: "${query}" in ${cwd}`);
+        if (signal?.aborted) {
+            throw new Error('Operation cancelled by user');
+        }
+        let output = '';
+        const result = await spawnCommand({
+            command: 'rg',
+            args: [
+                '-n',
+                '--json',
+                '-i',
+                '--max-count',
+                '100',
+                '--glob',
+                '!.git',
+                '--glob',
+                '!node_modules',
+                '--',
+                query,
+                '.',
+            ],
+            cwd,
+            signal,
+            timeoutMs: LIMITS.defaultToolTimeoutMs,
+            onStdoutChunk: (data) => {
+                output += Buffer.from(data).toString();
+            },
+        });
+        if (signal?.aborted || result.aborted) {
+            throw new Error('Operation cancelled by user');
+        }
+        getLogger().trace(`  [RG] Process closed with code ${result.code}. Output length: ${output.length}`);
+        if (result.error) {
+            if (result.error.code === 'ENOENT') {
+                getLogger().error('Error: ripgrep (rg) not found in PATH. Context gathering may be incomplete.');
+            }
+            else {
+                getLogger().error(`Error running ripgrep: ${result.error.message}`);
+            }
+            return [];
+        }
+        if (result.timedOut) {
+            getLogger().trace(`  [RG] Timeout reached for query: "${query}".`);
+            return [];
+        }
+        if (result.code !== 0 && result.code !== 1) {
+            return [];
+        }
+        const results = [];
+        const lines = output.trim().split('\n');
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const data = JSON.parse(line);
+                if (data.type === 'match') {
+                    results.push({
+                        file: normalizePath(String(data.data.path.text)),
+                        line: data.data.line_number,
+                        content: data.data.lines.text.replace(/\n$/, ''),
+                    });
+                }
+            }
+            catch {
+                // Ignore malformed JSON.
+            }
+        }
+        return results;
+    }
+    async searchMultipleKeywords(keywords, cwd, signal) {
+        if (keywords.length === 0)
+            return [];
+        if (signal?.aborted)
+            throw new Error('Operation cancelled by user');
+        const cappedKeywords = keywords.slice(0, LIMITS.maxKeywords);
+        getLogger().trace(`  [CONTEXT] Searching keywords: ${cappedKeywords.join(', ')}`);
+        const searchPromises = cappedKeywords.map((keyword) => this.runRipgrep(keyword, cwd, signal));
+        const resultsArrays = await Promise.all(searchPromises);
+        const seen = new Set();
+        const mergedResults = [];
+        for (const results of resultsArrays) {
+            for (const result of results) {
+                const key = `${result.file}:${result.line}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    mergedResults.push(result);
+                }
+            }
+        }
+        const limitedResults = mergedResults.slice(0, 50);
+        return limitedResults.sort((a, b) => {
+            if (a.file !== b.file)
+                return a.file.localeCompare(b.file);
+            return a.line - b.line;
+        });
+    }
+}
+//# sourceMappingURL=ripgrep-gatherer.js.map

package/dist/core/context/hash.js

@@ -0,0 +1,52 @@
+import { createHash } from 'node:crypto';
+function stableValue(value) {
+    if (Array.isArray(value))
+        return value.map((item) => stableValue(item));
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value)
+            .filter(([, v]) => v !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([k, v]) => [k, stableValue(v)]);
+        return Object.fromEntries(entries);
+    }
+    return value;
+}
+function hashStable(value) {
+    return createHash('sha1')
+        .update(JSON.stringify(stableValue(value)))
+        .digest('hex');
+}
+const SIGNATURE_VERSION = 'v1';
+export function createIntentSignature(input) {
+    return `intent:${SIGNATURE_VERSION}:${hashStable({
+        instruction: input.instruction ?? '',
+        primaryFile: input.primaryFile ?? '',
+        selection: input.selection ?? '',
+        diffScope: input.diffScope ?? 'primary',
+    })}`;
+}
+export function createTargetSetSignature(targets) {
+    const normalized = (targets ?? [])
+        .map((t) => ({
+        path: t.path,
+        reason: t.reason,
+        confidence: t.confidence,
+        churnWeight: t.churnWeight ? Number(t.churnWeight.toFixed(4)) : 0,
+        ranking: t.ranking
+            ? {
+                semanticScore: Number(t.ranking.semanticScore.toFixed(4)),
+                churnScore: Number(t.ranking.churnScore.toFixed(4)),
+                primaryBoostScore: Number(t.ranking.primaryBoostScore.toFixed(4)),
+                finalScore: Number(t.ranking.finalScore.toFixed(6)),
+            }
+            : undefined,
+    }))
+        .sort((a, b) => a.path.localeCompare(b.path) ||
+        a.reason.localeCompare(b.reason) ||
+        a.confidence.localeCompare(b.confidence));
+    return `targets:${SIGNATURE_VERSION}:${hashStable(normalized)}`;
+}
+export function createContextHash(context) {
+    return `context:${SIGNATURE_VERSION}:${hashStable(context)}`;
+}
+//# sourceMappingURL=hash.js.map

package/dist/core/context/index.js

@@ -0,0 +1,3 @@
+export { ContextService } from './service.js';
+export { DefaultPromptAssembler } from './assembly/default-prompt-assembler.js';
+//# sourceMappingURL=index.js.map

package/dist/core/context/keywords.js

@@ -0,0 +1,179 @@
+// Language-agnostic stopwords (common across languages)
+const STOPWORDS = new Set([
+    // English
+    'the',
+    'is',
+    'a',
+    'an',
+    'to',
+    'of',
+    'and',
+    'in',
+    'on',
+    'at',
+    'for',
+    'with',
+    'fix',
+    'add',
+    'remove',
+    'update',
+    'delete',
+    'create',
+    'make',
+    'implement',
+    'please',
+    'help',
+    'todo',
+    'bug',
+    'issue',
+    'error',
+    'fail',
+    'failed',
+    // Chinese common words
+    '的',
+    '了',
+    '在',
+    '是',
+    '我',
+    '有',
+    '和',
+    '就',
+    '不',
+    '人',
+    '都',
+    '一',
+    '一个',
+    '上',
+    '也',
+    '很',
+    '到',
+    '说',
+    '要',
+    '去',
+    '你',
+    '会',
+    '着',
+    '没有',
+    '看',
+    '好',
+    '自己',
+    '这',
+    '那',
+    '里',
+    '什么',
+    '怎么',
+]);
+function uniquePreserveOrder(items) {
+    const seen = new Set();
+    const out = [];
+    for (const item of items) {
+        const key = item.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(item);
+    }
+    return out;
+}
+function extractPathLikeTokens(input) {
+    const matches = input.match(/(?:^|[\s"'`([{])((?:\.{0,2}\/)?[\w./-]+\.(?:ts|tsx|js|jsx|json|md|yml|yaml|css|scss|html))(?:$|[\s"'`)\]}.,;:])/g);
+    if (!matches)
+        return [];
+    return matches
+        .map((m) => m.replace(/^[\s"'`([{]+/, '').replace(/[\s"'`)\]}.,;:]+$/, ''))
+        .filter(Boolean);
+}
+function extractBacktickedTokens(input) {
+    const matches = [];
+    const re = /`([^`]{1,64})`/g;
+    let m;
+    while ((m = re.exec(input)) !== null) {
+        const val = m[1]?.trim();
+        if (val)
+            matches.push(val);
+    }
+    return matches;
+}
+function extractErrorLikeTokens(input) {
+    const matches = [];
+    const re = /\b(ERR_[A-Z0-9_]{2,}|[A-Z][A-Za-z]+Error)\b/g;
+    let m;
+    while ((m = re.exec(input)) !== null) {
+        if (m[1])
+            matches.push(m[1]);
+    }
+    return matches;
+}
+function extractIdentifierTokens(input) {
+    const matches = [];
+    const re = /\b[A-Za-z_][A-Za-z0-9_]{2,}\b/g;
+    let m;
+    while ((m = re.exec(input)) !== null) {
+        if (m[0])
+            matches.push(m[0]);
+    }
+    return matches;
+}
+function isCjk(char) {
+    return /\p{Script=Han}|\p{Script=Hiragana}|\p{Script=Katakana}|\p{Script=Hangul}/u.test(char);
+}
+function extractCjkNgrams(input, n) {
+    const chars = Array.from(input).filter((c) => isCjk(c));
+    if (chars.length < n)
+        return [];
+    const counts = new Map();
+    for (let i = 0; i <= chars.length - n; i++) {
+        const gram = chars.slice(i, i + n).join('');
+        // Filter out stopwords
+        if (!STOPWORDS.has(gram)) {
+            counts.set(gram, (counts.get(gram) ?? 0) + 1);
+        }
+    }
+    return Array.from(counts.entries())
+        .sort((a, b) => b[1] - a[1])
+        .map(([gram]) => gram);
+}
+export function extractKeywords(instruction) {
+    const raw = instruction.trim();
+    if (!raw)
+        return [];
+    // Priority 1: Path-like tokens (highest signal)
+    const pathLike = extractPathLikeTokens(raw);
+    // Priority 2: Backticked tokens (explicit emphasis)
+    const backticked = extractBacktickedTokens(raw);
+    // Priority 3: Error-like tokens (strong signal)
+    const errorLike = extractErrorLikeTokens(raw);
+    // Priority 4: Identifiers (code-related)
+    const identifiers = extractIdentifierTokens(raw);
+    // Priority 5: Word tokens
+    const wordTokens = raw
+        .toLowerCase()
+        .split(/[^\p{L}\p{N}_-]+/u)
+        .filter(Boolean);
+    // Combine with priority order
+    const ordered = uniquePreserveOrder([
+        ...pathLike,
+        ...backticked,
+        ...errorLike,
+        ...identifiers,
+        ...wordTokens,
+    ]);
+    // Filter out stopwords and short tokens
+    const filtered = ordered
+        .map((t) => t.trim())
+        .filter(Boolean)
+        .filter((t) => t.length >= 2) // Reduced from 3 to support CJK
+        .filter((t) => !STOPWORDS.has(t.toLowerCase()) && !STOPWORDS.has(t));
+    // Take top 5 keywords (increased from 3)
+    const selected = filtered.slice(0, 5);
+    if (selected.length > 0)
+        return selected;
+    // Fallback: CJK n-grams
+    const hasCjk = Array.from(raw).some((c) => isCjk(c));
+    if (!hasCjk)
+        return [];
+    // Extract CJK n-grams (3-char and 2-char)
+    const grams = uniquePreserveOrder([...extractCjkNgrams(raw, 3), ...extractCjkNgrams(raw, 2)]);
+    return grams.slice(0, 5);
+}
+//# sourceMappingURL=keywords.js.map

package/dist/core/context/policies/budget-policy.js

@@ -0,0 +1,36 @@
+import { LIMITS } from '../../config/limits.js';
+export function buildContextBudgetPolicyPlan(input) {
+    const requestedBudgetChars = typeof input.requestedBudgetChars === 'number'
+        ? input.requestedBudgetChars
+        : LIMITS.maxContextChars;
+    return {
+        shouldAbort: false,
+        workerId: 'context-budget-policy',
+        actions: [
+            {
+                type: 'PACK_UNTIL_FULL',
+                params: { budgetChars: requestedBudgetChars, mode: 'equivalent' },
+            },
+            {
+                type: 'BUDGET_META',
+                params: {
+                    preBudgetSectionChars: input.preBudgetSectionChars,
+                    targetCount: input.targetCount,
+                },
+            },
+        ],
+        decisionTree: [
+            `Budget Policy: requestedBudgetChars=${requestedBudgetChars}`,
+            'Action: PACK_UNTIL_FULL (equivalent)',
+            `Meta: targetCount=${input.targetCount}`,
+        ],
+    };
+}
+export function executeContextBudgetPolicyPlan(args) {
+    const action = args.plan.actions.find((a) => a.type === 'PACK_UNTIL_FULL');
+    const plannedBudget = action?.params && typeof action.params.budgetChars === 'number'
+        ? action.params.budgetChars
+        : args.fallbackBudgetChars;
+    return args.pack(args.context, plannedBudget);
+}
+//# sourceMappingURL=budget-policy.js.map