salmon-loop 0.2.3

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

@@ -0,0 +1,370 @@
+import { text } from '../../../locales/index.js';
+import { FileAdapter } from '../../adapters/fs/file-adapter.js';
+import { AstParser } from '../../ast/parser.js';
+import { checkSyntaxErrors } from '../../ast/validator.js';
+import { LIMITS } from '../../config/limits.js';
+import { getLogger } from '../../observability/logger.js';
+import { getPluginRegistry } from '../../plugin/registry.js';
+import { normalizePath, safeJoin } from '../../utils/path.js';
+import { extractImportSpecifiers } from '../ast/import-extractor.js';
+import { resolveImportCandidates } from '../ast/module-resolver.js';
+import { outlineSource } from '../ast/source-outline.js';
+const AST_DEEP_TRIGGER_PATTERN = /\b(refactor|rename|migrate|cross[- ]?file|across|dependency|dependencies|module|architecture|global)\b/i;
+function getImportScanDepth(req) {
+    const instruction = req.instruction || '';
+    if (AST_DEEP_TRIGGER_PATTERN.test(instruction)) {
+        return { depth: LIMITS.maxDependencyDepth, trigger: 'deep' };
+    }
+    return { depth: 1, trigger: 'shallow' };
+}
+async function buildSymbolMap(symbols, primaryFile, callNames, relatedFiles) {
+    const definitions = symbols.filter((s) => s.kind === 'definition');
+    const references = symbols.filter((s) => s.kind === 'reference');
+    const nodes = [];
+    const edges = [];
+    const definitionNodeByName = new Map();
+    // Process primary file symbols
+    for (const def of definitions) {
+        const id = `def:${def.name}:${def.location.start.line}:${def.location.start.column}`;
+        definitionNodeByName.set(def.name, id);
+        nodes.push({
+            id,
+            name: def.name,
+            kind: 'definition',
+            path: primaryFile,
+            location: def.location,
+        });
+    }
+    for (const ref of references) {
+        const refId = `ref:${ref.name}:${ref.location.start.line}:${ref.location.start.column}`;
+        nodes.push({
+            id: refId,
+            name: ref.name,
+            kind: 'reference',
+            path: primaryFile,
+            location: ref.location,
+        });
+        const targetDefId = definitionNodeByName.get(ref.name);
+        if (!targetDefId)
+            continue;
+        const edgeType = callNames.includes(ref.name) ? 'call' : 'reference';
+        edges.push({
+            from: refId,
+            to: targetDefId,
+            type: edgeType,
+            confidence: 'high',
+        });
+    }
+    // Process imported files
+    for (const related of relatedFiles) {
+        if (related.kind !== 'import' || related.mode !== 'full')
+            continue;
+        const lang = getLanguageFromFile(related.path);
+        if (!lang)
+            continue;
+        try {
+            const tree = await AstParser.parse(related.content, lang);
+            const defs = await AstParser.identifyDefinitions(tree, lang);
+            for (const def of defs) {
+                const id = `def:${related.path}:${def.name}:${def.location.start.line}:${def.location.start.column}`;
+                nodes.push({
+                    id,
+                    name: def.name,
+                    kind: 'definition',
+                    path: related.path,
+                    location: def.location,
+                });
+                // Allow cross-file references to find these definitions
+                if (!definitionNodeByName.has(def.name)) {
+                    definitionNodeByName.set(def.name, id);
+                }
+            }
+        }
+        catch (e) {
+            getLogger().debug(`  [CONTEXT] Failed to extract symbols from ${related.path}: ${e}`);
+        }
+    }
+    return { symbolMap: { nodes, edges } };
+}
+function summarizeControlFlow(primaryText) {
+    const branchMatches = primaryText.match(/\b(if|else\s+if|switch|\?)\b/g) || [];
+    const loopMatches = primaryText.match(/\b(for|while|do)\b/g) || [];
+    const asyncMatches = primaryText.match(/\b(await|Promise\.all|Promise\.race|setTimeout|setInterval)\b/g) || [];
+    const tryCatchMatches = primaryText.match(/\btry\b|\bcatch\b/g) || [];
+    const throwMatches = primaryText.match(/\bthrow\b/g) || [];
+    const promiseCatchMatches = primaryText.match(/\.catch\s*\(/g) || [];
+    const controlHotspots = [];
+    if (branchMatches.length >= 3)
+        controlHotspots.push('dense_branching');
+    if (loopMatches.length >= 2)
+        controlHotspots.push('nested_or_multiple_loops');
+    if (asyncMatches.length >= 2)
+        controlHotspots.push('multiple_async_boundaries');
+    const exceptionHotspots = [];
+    if (tryCatchMatches.length >= 2)
+        exceptionHotspots.push('multiple_try_catch_paths');
+    if (throwMatches.length >= 2)
+        exceptionHotspots.push('multiple_throw_sites');
+    if (promiseCatchMatches.length >= 2)
+        exceptionHotspots.push('multiple_promise_catch_paths');
+    return {
+        controlFlow: {
+            branchCount: branchMatches.length,
+            loopCount: loopMatches.length,
+            asyncBoundaryCount: asyncMatches.length,
+            hotspots: controlHotspots,
+        },
+        exceptionPaths: {
+            tryCatchCount: Math.floor(tryCatchMatches.length / 2),
+            throwCount: throwMatches.length,
+            promiseCatchCount: promiseCatchMatches.length,
+            hotspots: exceptionHotspots,
+        },
+    };
+}
+function getPluginByFile(filePath) {
+    return getPluginRegistry().getByExtension(filePath);
+}
+/**
+ * Resolve language ID from file path using plugin registry.
+ * Zero hardcoded language mappings - fully dynamic via registered plugins.
+ */
+function getLanguageFromFile(filePath) {
+    const plugin = getPluginByFile(filePath);
+    return plugin?.meta.id;
+}
+export class AstGatherer {
+    fileAdapter = new FileAdapter();
+    async gather(primaryText, req) {
+        if (!primaryText || !req.primaryFile) {
+            return { symbols: [], definitionMap: {}, relatedFiles: [] };
+        }
+        const diagnostics = await this.gatherDiagnostics(primaryText, req.primaryFile);
+        const symbolsResult = await this.gatherSymbols(primaryText, req.primaryFile, diagnostics.tree);
+        const languagePlugin = getPluginByFile(req.primaryFile);
+        const callNames = await this.gatherCallNames(diagnostics.tree, getLanguageFromFile(req.primaryFile), languagePlugin?.parsing?.queryPack?.symbols?.calls);
+        const deepAnalysis = await this.gatherDeepAnalysis(primaryText, diagnostics.tree, getLanguageFromFile(req.primaryFile), languagePlugin?.parsing?.queryPack?.flow);
+        const importedResult = await this.gatherImportedFiles(primaryText, req);
+        const { symbolMap } = await buildSymbolMap(symbolsResult.symbols, req.primaryFile, callNames, importedResult.relatedFiles);
+        return {
+            symbols: symbolsResult.symbols,
+            definitionMap: symbolsResult.definitionMap,
+            relatedFiles: importedResult.relatedFiles,
+            repoMap: importedResult.repoMap,
+            symbolMap,
+            controlFlow: deepAnalysis.controlFlow,
+            exceptionPaths: deepAnalysis.exceptionPaths,
+            languageId: diagnostics.languageId,
+            syntaxErrors: diagnostics.syntaxErrors,
+            parseError: diagnostics.parseError,
+        };
+    }
+    async gatherSymbols(primaryText, primaryFile, parsedTree) {
+        try {
+            const lang = getLanguageFromFile(primaryFile);
+            if (!lang)
+                return { symbols: [], definitionMap: {} };
+            const tree = parsedTree ?? (await AstParser.parse(primaryText, lang));
+            const defs = await AstParser.identifyDefinitions(tree, lang);
+            const refs = await AstParser.identifyReferences(tree, lang);
+            const definitionMap = {};
+            for (const def of defs) {
+                definitionMap[def.name] = def.location;
+            }
+            return { symbols: [...defs, ...refs], definitionMap };
+        }
+        catch (e) {
+            getLogger().debug(`  [CONTEXT] Symbol extraction unavailable for ${primaryFile}: ${e}`);
+            return { symbols: [], definitionMap: {} };
+        }
+    }
+    async gatherCallNames(parsedTree, lang, callsQuery) {
+        if (!parsedTree || !lang || !callsQuery)
+            return [];
+        const queryFn = AstParser.queryCapturesFromQuery;
+        if (typeof queryFn !== 'function')
+            return [];
+        const captures = (await queryFn(parsedTree, lang, callsQuery));
+        return Array.from(new Set(captures
+            .filter((c) => c.name === 'callee' && c.text.trim().length > 0)
+            .map((c) => c.text.trim())));
+    }
+    async gatherDeepAnalysis(primaryText, parsedTree, lang, flowPack) {
+        const queryFn = AstParser.queryCapturesFromQuery;
+        if (!parsedTree ||
+            !lang ||
+            !flowPack?.control ||
+            !flowPack?.exceptions ||
+            typeof queryFn !== 'function') {
+            return summarizeControlFlow(primaryText);
+        }
+        const controlCaptures = (await queryFn(parsedTree, lang, flowPack.control));
+        const exceptionCaptures = (await queryFn(parsedTree, lang, flowPack.exceptions));
+        const branchCount = controlCaptures.filter((c) => c.name === 'branch').length;
+        const loopCount = controlCaptures.filter((c) => c.name === 'loop').length;
+        const asyncBoundaryCount = controlCaptures.filter((c) => c.name === 'async').length;
+        const tryCatchCount = exceptionCaptures.filter((c) => c.name === 'trycatch').length;
+        const throwCount = exceptionCaptures.filter((c) => c.name === 'throw').length;
+        const promiseCatchCount = exceptionCaptures.filter((c) => c.name === 'catch').length;
+        return {
+            controlFlow: {
+                branchCount,
+                loopCount,
+                asyncBoundaryCount,
+                hotspots: [
+                    ...(branchCount >= 3 ? ['dense_branching'] : []),
+                    ...(loopCount >= 2 ? ['nested_or_multiple_loops'] : []),
+                    ...(asyncBoundaryCount >= 2 ? ['multiple_async_boundaries'] : []),
+                ],
+            },
+            exceptionPaths: {
+                tryCatchCount,
+                throwCount,
+                promiseCatchCount,
+                hotspots: [
+                    ...(tryCatchCount >= 2 ? ['multiple_try_catch_paths'] : []),
+                    ...(throwCount >= 2 ? ['multiple_throw_sites'] : []),
+                    ...(promiseCatchCount >= 2 ? ['multiple_promise_catch_paths'] : []),
+                ],
+            },
+        };
+    }
+    async gatherDiagnostics(primaryText, primaryFile) {
+        const languageId = getLanguageFromFile(primaryFile);
+        if (!languageId)
+            return { languageId: undefined, syntaxErrors: undefined, parseError: undefined };
+        try {
+            const tree = await AstParser.parse(primaryText, languageId);
+            const rawErrors = checkSyntaxErrors(tree);
+            const syntaxErrors = rawErrors.length > 0
+                ? rawErrors.slice(0, 50).map((e) => ({
+                    line: e.line + 1,
+                    column: e.column + 1,
+                    type: e.type,
+                    text: String(e.text || '').slice(0, 200),
+                }))
+                : [];
+            return {
+                languageId,
+                syntaxErrors,
+                tree,
+            };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            getLogger().debug(`  [CONTEXT] AST diagnostics unavailable for ${primaryFile}: ${msg}`);
+            return { languageId, syntaxErrors: undefined, parseError: msg };
+        }
+    }
+    async gatherImportedFiles(primaryText, req) {
+        const primaryPath = normalizePath(req.primaryFile || '').replace(/^(\.\/|\/)+/, '');
+        const depthSettings = getImportScanDepth(req);
+        const queue = [
+            { from: primaryPath, text: primaryText, depth: 1 },
+        ];
+        const visitedForScan = new Set();
+        const related = [];
+        const relatedSeen = new Set();
+        const repoNodes = new Map();
+        const repoEdges = new Map();
+        if (primaryPath) {
+            repoNodes.set(primaryPath, { path: primaryPath, depth: 0, source: 'primary' });
+        }
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (visitedForScan.has(current.from))
+                continue;
+            visitedForScan.add(current.from);
+            const specifiers = extractImportSpecifiers(current.text).filter((s) => s.startsWith('.'));
+            for (const spec of specifiers) {
+                const candidates = resolveImportCandidates({
+                    currentFile: current.from,
+                    specifier: spec,
+                });
+                if (candidates.length === 0)
+                    continue;
+                const resolved = await this.pickFirstExisting(req, candidates);
+                if (!resolved)
+                    continue;
+                const normalized = normalizePath(resolved).replace(/^(\.\/|\/)+/, '');
+                if (!normalized || normalized === primaryPath)
+                    continue;
+                const edgeKey = `${current.from}->${normalized}`;
+                if (!repoEdges.has(edgeKey)) {
+                    repoEdges.set(edgeKey, { from: current.from, to: normalized, type: 'import' });
+                }
+                const existingNode = repoNodes.get(normalized);
+                if (!existingNode || existingNode.depth > current.depth) {
+                    repoNodes.set(normalized, {
+                        path: normalized,
+                        depth: current.depth,
+                        source: 'import',
+                    });
+                }
+                const content = await this.readRepoFile(req, normalized);
+                if (content === null)
+                    continue;
+                if (!relatedSeen.has(normalized)) {
+                    relatedSeen.add(normalized);
+                    const outline = outlineSource(content);
+                    const isLarge = content.length > LIMITS.largeFileThresholdBytes;
+                    related.push({
+                        path: normalized,
+                        kind: 'import',
+                        mode: isLarge ? 'outline' : 'full',
+                        content: isLarge ? `${outline}\n\n${text.context.relatedContentTruncated}` : content,
+                        outline: isLarge ? undefined : outline || undefined,
+                    });
+                }
+                if (current.depth < depthSettings.depth &&
+                    !visitedForScan.has(normalized) &&
+                    repoNodes.size < LIMITS.maxRelatedFiles + 1) {
+                    queue.push({ from: normalized, text: content, depth: current.depth + 1 });
+                }
+            }
+        }
+        return {
+            relatedFiles: related,
+            repoMap: {
+                nodes: Array.from(repoNodes.values()),
+                edges: Array.from(repoEdges.values()),
+                maxDepth: depthSettings.depth,
+                trigger: depthSettings.trigger,
+            },
+        };
+    }
+    async pickFirstExisting(req, candidates) {
+        for (const c of candidates) {
+            if (req.snapshotHash && req.checkpointManager) {
+                const content = await req.checkpointManager
+                    .readSnapshotFile(req.repoPath, req.snapshotHash, c)
+                    .catch(() => null);
+                if (content !== null)
+                    return c;
+                continue;
+            }
+            try {
+                await this.fileAdapter.readFile(safeJoin(req.repoPath, c), 'utf-8');
+                return c;
+            }
+            catch {
+                // continue
+            }
+        }
+        return null;
+    }
+    async readRepoFile(req, filePath) {
+        if (req.snapshotHash && req.checkpointManager) {
+            return await req.checkpointManager
+                .readSnapshotFile(req.repoPath, req.snapshotHash, filePath)
+                .catch(() => null);
+        }
+        try {
+            return await this.fileAdapter.readFile(safeJoin(req.repoPath, filePath), 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=ast-gatherer.js.map

package/dist/core/context/gatherers/ghost-dependency-gatherer.js

@@ -0,0 +1,46 @@
+import { normalizePath } from '../../utils/path.js';
+export class GhostDependencyGatherer {
+    ripgrep;
+    constructor(ripgrep) {
+        this.ripgrep = ripgrep;
+    }
+    async gather(primaryText, req, existingFiles) {
+        if (!primaryText)
+            return [];
+        // 1. Extract potential "Ghost Tokens" (UpperCamelCase, SCREAMING_SNAKE_CASE, or unique strings)
+        const ghostTokens = Array.from(new Set(primaryText.match(/\b[A-Z][a-zA-Z0-9]{5,}\b|\b[A-Z_]{5,}\b/g) || [])).slice(0, 10); // Limit to top 10 tokens for performance
+        if (ghostTokens.length === 0)
+            return [];
+        // 2. Search for these tokens in the repo
+        const snippets = await this.ripgrep.searchMultipleKeywords(ghostTokens, req.repoPath, req.signal);
+        // 3. Identify files that contain these tokens but aren't in existing dependency tree
+        const ghostFiles = new Map();
+        const primaryPath = normalizePath(req.primaryFile || '');
+        for (const s of snippets) {
+            const sPath = normalizePath(s.file);
+            if (sPath === primaryPath || existingFiles.has(sPath))
+                continue;
+            const entry = ghostFiles.get(sPath) || { tokens: new Set(), count: 0 };
+            ghostTokens.forEach((t) => {
+                if (s.content.includes(t))
+                    entry.tokens.add(t);
+            });
+            entry.count++;
+            ghostFiles.set(sPath, entry);
+        }
+        // 4. Rank and return top ghost candidates
+        return Array.from(ghostFiles.entries())
+            .filter(([_, data]) => data.tokens.size >= 1) // Must share at least one significant token
+            .sort((a, b) => b[1].tokens.size - a[1].tokens.size || b[1].count - a[1].count)
+            .slice(0, 3) // Only pick top 3 most likely ghosts to keep context lean
+            .map(([path, data]) => ({
+            path,
+            kind: 'dependency',
+            mode: 'outline',
+            content: `// Ghost Dependency: Shares tokens [${Array.from(data.tokens).join(', ')}]
+`,
+            reason: 'ghost_dependency',
+        }));
+    }
+}
+//# sourceMappingURL=ghost-dependency-gatherer.js.map

package/dist/core/context/gatherers/git-diff-gatherer.js

@@ -0,0 +1,91 @@
+import { FileAdapter } from '../../adapters/fs/file-adapter.js';
+import { GitAdapter } from '../../adapters/git/git-adapter.js';
+import { defaultPathAdapter } from '../../adapters/path/path-adapter.js';
+import { LIMITS } from '../../config/limits.js';
+import { getLogger } from '../../observability/logger.js';
+import { normalizePath } from '../../utils/path.js';
+import { findFileDependencies } from '../dependencies.js';
+const fileAdapter = new FileAdapter();
+function uniqPaths(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;
+}
+async function runGitDiff(cwd, cached, files) {
+    const args = ['diff'];
+    if (cached)
+        args.push('--cached');
+    if (files.length > 0)
+        args.push('--', ...files);
+    const git = new GitAdapter(cwd);
+    const res = await git.execMeta(args, {
+        cwd,
+        limits: { maxStdoutBytes: LIMITS.maxToolOutputBytes, maxStderrChars: 16_384 },
+        timeoutMs: LIMITS.gitTimeoutMs,
+    });
+    if (!res.ok)
+        return undefined;
+    if (res.stdoutTruncated) {
+        getLogger().debug(`[GitDiffGatherer] git diff stdout truncated at ${LIMITS.maxToolOutputBytes} bytes (args=${args.join(' ')}); dropping diff for safety`);
+        return undefined;
+    }
+    const output = res.stdout.toString('utf8');
+    return output.trim() ? output : undefined;
+}
+async function resolveDiffFiles(req, scope) {
+    if (!req.primaryFile)
+        return [];
+    if (scope === 'primary')
+        return [req.primaryFile];
+    const deps = await findFileDependencies(req.primaryFile, req.repoPath).catch(() => []);
+    const all = uniqPaths([req.primaryFile, ...deps]).slice(0, LIMITS.maxRelatedFiles);
+    return await resolveSourcePaths(req.repoPath, all);
+}
+async function resolveSourcePaths(repoPath, files) {
+    const resolved = [];
+    for (const file of files) {
+        const normalized = normalizePath(file);
+        const full = defaultPathAdapter.join(repoPath, normalized);
+        if (await exists(full)) {
+            resolved.push(normalized);
+            continue;
+        }
+        const mapped = mapEsmImportPathToSource(normalized);
+        if (mapped !== normalized && (await exists(defaultPathAdapter.join(repoPath, mapped)))) {
+            resolved.push(mapped);
+            continue;
+        }
+        resolved.push(normalized);
+    }
+    return uniqPaths(resolved);
+}
+function mapEsmImportPathToSource(filePath) {
+    if (filePath.endsWith('.js'))
+        return filePath.replace(/\.js$/, '.ts');
+    if (filePath.endsWith('.jsx'))
+        return filePath.replace(/\.jsx$/, '.tsx');
+    return filePath;
+}
+async function exists(p) {
+    return await fileAdapter.exists(p);
+}
+export class GitDiffGatherer {
+    async gather(req) {
+        const scope = req.diffScope ?? 'primary';
+        const files = await resolveDiffFiles(req, scope);
+        const stagedDiff = await runGitDiff(req.repoPath, true, files);
+        const unstagedDiff = await runGitDiff(req.repoPath, false, files);
+        const gitDiff = [stagedDiff, unstagedDiff].filter(Boolean).join('\n').trim() || undefined;
+        return { stagedDiff, unstagedDiff, gitDiff, includedFiles: files };
+    }
+}
+//# sourceMappingURL=git-diff-gatherer.js.map

package/dist/core/context/gatherers/git-history-gatherer.js

@@ -0,0 +1,57 @@
+import { GitAdapter } from '../../adapters/git/git-adapter.js';
+import { normalizePath } from '../../utils/path.js';
+function buildChurnIndex(logOutput) {
+    const churn = {};
+    for (const rawLine of logOutput.split('\n')) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const normalized = normalizePath(line).replace(/^(\.\/|\/)+/, '');
+        if (!normalized)
+            continue;
+        churn[normalized] = (churn[normalized] ?? 0) + 1;
+    }
+    return churn;
+}
+function buildChurnIndexFromNumstat(logOutput) {
+    const churn = {};
+    for (const rawLine of logOutput.split('\n')) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const match = line.match(/^(\d+|-)\s+(\d+|-)\s+(.+)$/);
+        if (!match)
+            continue;
+        const added = match[1] === '-' ? 0 : Number(match[1]);
+        const deleted = match[2] === '-' ? 0 : Number(match[2]);
+        const filePath = normalizePath(match[3] ?? '').replace(/^(\.\/|\/)+/, '');
+        if (!filePath)
+            continue;
+        churn[filePath] = (churn[filePath] ?? 0) + added + deleted;
+    }
+    return churn;
+}
+export class GitHistoryGatherer {
+    async gather(req) {
+        const { repoPath } = req;
+        try {
+            const git = new GitAdapter(repoPath);
+            // Use GitAdapter's query method for standard git commands
+            const stdout = await git.query(['log', '-n', '5', '--oneline']);
+            const churnNumstatLog = await git
+                .query(['log', '-n', '40', '--numstat', '--pretty=format:'])
+                .catch(() => '');
+            const churnLog = await git.query(['log', '-n', '40', '--name-only', '--pretty=format:']);
+            const churnByNumstat = buildChurnIndexFromNumstat(churnNumstatLog);
+            return {
+                recentCommits: stdout.trim(),
+                churnByFile: Object.keys(churnByNumstat).length > 0 ? churnByNumstat : buildChurnIndex(churnLog),
+            };
+        }
+        catch {
+            // Not a git repo or git not found
+            return {};
+        }
+    }
+}
+//# sourceMappingURL=git-history-gatherer.js.map

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

@@ -0,0 +1,101 @@
+import { FileAdapter } from '../../adapters/fs/file-adapter.js';
+import { getDefaultIndexPath } from '../../config/paths.js';
+import { getLogger } from '../../observability/logger.js';
+import { safeJoin } from '../../utils/path.js';
+export class KnowledgeGatherer {
+    static KNOWLEDGE_SUBDIR = 'knowledge';
+    static SNAPSHOT_FILE = 'snapshot.json';
+    static COMPACTION_THRESHOLD = 20; // Compact after 20 events
+    fileAdapter = new FileAdapter();
+    async gather(req) {
+        const { repoPath } = req;
+        const indexPath = getDefaultIndexPath(repoPath);
+        const knowledgeDir = safeJoin(indexPath, KnowledgeGatherer.KNOWLEDGE_SUBDIR);
+        const aggregated = {
+            project_rules: undefined,
+            architectural_decisions: [],
+            user_preferences: undefined,
+        };
+        const allDeprecated = new Set();
+        try {
+            const allFiles = await this.fileAdapter.readdir(knowledgeDir);
+            // Sort files by timestamp (ascending) to apply Last-Writer-Wins correctly
+            // We process snapshot.json first if it exists, then all event files
+            const eventFiles = allFiles
+                .filter((f) => f.endsWith('.json') && f !== KnowledgeGatherer.SNAPSHOT_FILE)
+                .sort();
+            // 1. Load Snapshot if exists
+            if (allFiles.includes(KnowledgeGatherer.SNAPSHOT_FILE)) {
+                try {
+                    const snapshotContent = await this.fileAdapter.readFile(safeJoin(knowledgeDir, KnowledgeGatherer.SNAPSHOT_FILE), 'utf-8');
+                    const snapshotData = JSON.parse(snapshotContent);
+                    Object.assign(aggregated, snapshotData);
+                    if (snapshotData.deprecated_rules) {
+                        snapshotData.deprecated_rules.forEach((r) => allDeprecated.add(r));
+                    }
+                }
+                catch (e) {
+                    getLogger().warn(`[KnowledgeGatherer] Failed to load snapshot: ${e}`);
+                }
+            }
+            // 2. Load and Apply Events
+            for (const file of eventFiles) {
+                try {
+                    const content = await this.fileAdapter.readFile(safeJoin(knowledgeDir, file), 'utf-8');
+                    const data = JSON.parse(content);
+                    if (data.project_rules) {
+                        aggregated.project_rules = data.project_rules;
+                    }
+                    if (data.deprecated_rules) {
+                        data.deprecated_rules.forEach((r) => allDeprecated.add(r));
+                    }
+                    if (data.architectural_decisions) {
+                        aggregated.architectural_decisions.push(...data.architectural_decisions);
+                    }
+                    if (data.user_preferences) {
+                        aggregated.user_preferences = data.user_preferences;
+                    }
+                }
+                catch {
+                    // Skip corrupted files
+                }
+            }
+            // Filter out deprecated rules from aggregated project_rules
+            if (aggregated.project_rules) {
+                aggregated.project_rules = aggregated.project_rules.filter((r) => !allDeprecated.has(r));
+            }
+            // 3. Optional Compaction
+            if (eventFiles.length >= KnowledgeGatherer.COMPACTION_THRESHOLD) {
+                // Run compaction in background (non-blocking)
+                this.compact(knowledgeDir, aggregated, eventFiles).catch((e) => getLogger().debug(`[KnowledgeGatherer] Compaction failed: ${e}`));
+            }
+        }
+        catch {
+            // Directory missing or other read errors, return empty aggregated state
+        }
+        return {
+            project_rules: aggregated.project_rules,
+            architectural_decisions: aggregated.architectural_decisions?.length
+                ? aggregated.architectural_decisions
+                : undefined,
+            user_preferences: aggregated.user_preferences,
+        };
+    }
+    async compact(knowledgeDir, aggregated, filesToMerge) {
+        getLogger().debug(`[KnowledgeGatherer] Compacting ${filesToMerge.length} knowledge events...`);
+        const snapshotPath = safeJoin(knowledgeDir, KnowledgeGatherer.SNAPSHOT_FILE);
+        try {
+            await this.fileAdapter.mkdir(knowledgeDir);
+            await this.fileAdapter.writeFile(snapshotPath, JSON.stringify(aggregated, null, 2));
+            // After successful snapshot write, delete merged event files
+            for (const file of filesToMerge) {
+                await this.fileAdapter.deleteFile(safeJoin(knowledgeDir, file)).catch(() => { });
+            }
+            getLogger().info(`[KnowledgeGatherer] Compaction complete. Merged into ${snapshotPath}`);
+        }
+        catch (e) {
+            throw new Error(`Failed to compact knowledge: ${e}`);
+        }
+    }
+}
+//# sourceMappingURL=knowledge-gatherer.js.map