salmon-loop 0.2.3

package/dist/core/context/formatters/xml-context.js

@@ -0,0 +1,296 @@
+import { text } from '../../../locales/index.js';
+import { normalizePath } from '../../utils/path.js';
+const ANALYSIS_LIMITS = {
+    maxParseErrorChars: 4000,
+    maxSyntaxErrors: 50,
+    maxNotes: 10,
+    maxNoteChars: 500,
+};
+function escapeXmlAttr(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/"/g, '"')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+function escapeCdata(text) {
+    return text.replace(/]]>/g, ']]]]><![CDATA[>');
+}
+function cdataBlock(content, indent) {
+    const safe = escapeCdata(content);
+    return `${indent}<![CDATA[\n${safe}\n${indent}]]>`;
+}
+function truncateText(value, maxChars) {
+    if (maxChars <= 0)
+        return '';
+    if (value.length <= maxChars)
+        return value;
+    return value.slice(0, maxChars);
+}
+function markSymbolsInText(context) {
+    const primaryText = context.primaryText;
+    const symbols = context.symbols;
+    if (!primaryText)
+        return primaryText;
+    if (!symbols || symbols.length === 0)
+        return primaryText;
+    const lines = primaryText.split('\n');
+    const sortedSymbols = [...symbols].sort((a, b) => {
+        if (a.location.start.line !== b.location.start.line) {
+            return b.location.start.line - a.location.start.line;
+        }
+        return b.location.start.column - a.location.start.column;
+    });
+    for (const symbol of sortedSymbols) {
+        const lineIdx = symbol.location.start.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length)
+            continue;
+        const marker = symbol.kind === 'definition' ? '' : text.symbols.info;
+        if (marker && !lines[lineIdx].endsWith(marker)) {
+            lines[lineIdx] += marker;
+        }
+    }
+    return lines.join('\n');
+}
+function renderPrimaryFile(context) {
+    const out = [];
+    if (!context.primaryText)
+        return out;
+    const primaryPath = context.primaryFile || 'Selection';
+    out.push(`  <primary_file path="${escapeXmlAttr(primaryPath)}">`);
+    out.push(cdataBlock(markSymbolsInText(context) ?? '', '    '));
+    out.push('  </primary_file>');
+    return out;
+}
+function renderManifest(context) {
+    const out = [];
+    const targets = context.targets;
+    const repoMap = context.repoMap;
+    const symbolMap = context.symbolMap;
+    if ((!targets || targets.length === 0) && !repoMap && !symbolMap)
+        return out;
+    out.push('  <manifest>');
+    if (targets && targets.length > 0) {
+        out.push('    <targets>');
+        for (const t of targets) {
+            // Handle both string and structured evidence
+            const evidenceStr = typeof t.evidence === 'string'
+                ? t.evidence
+                : t.evidence
+                    ? `${t.evidence.type}:${t.evidence.details?.symbolName || 'unknown'}`
+                    : undefined;
+            const evidenceAttr = evidenceStr ? ` evidence="${escapeXmlAttr(evidenceStr)}"` : '';
+            out.push(`      <target path="${escapeXmlAttr(normalizePath(t.path))}" reason="${escapeXmlAttr(t.reason)}" confidence="${escapeXmlAttr(t.confidence)}"${evidenceAttr} />`);
+        }
+        out.push('    </targets>');
+    }
+    if (repoMap) {
+        out.push(`    <repo_map trigger="${escapeXmlAttr(repoMap.trigger)}" max_depth="${repoMap.maxDepth}">`);
+        out.push('      <nodes>');
+        for (const node of repoMap.nodes) {
+            out.push(`        <node path="${escapeXmlAttr(normalizePath(node.path))}" depth="${node.depth}" source="${escapeXmlAttr(node.source)}" />`);
+        }
+        out.push('      </nodes>');
+        out.push('      <edges>');
+        for (const edge of repoMap.edges) {
+            out.push(`        <edge from="${escapeXmlAttr(normalizePath(edge.from))}" to="${escapeXmlAttr(normalizePath(edge.to))}" type="${escapeXmlAttr(edge.type)}" />`);
+        }
+        out.push('      </edges>');
+        out.push('    </repo_map>');
+    }
+    if (symbolMap) {
+        out.push('    <symbol_map>');
+        out.push('      <nodes>');
+        for (const node of symbolMap.nodes) {
+            const pathAttr = node.path ? ` path="${escapeXmlAttr(normalizePath(node.path))}"` : '';
+            out.push(`        <node id="${escapeXmlAttr(node.id)}" name="${escapeXmlAttr(node.name)}" kind="${escapeXmlAttr(node.kind)}"${pathAttr} line="${node.location.start.line}" column="${node.location.start.column}" />`);
+        }
+        out.push('      </nodes>');
+        out.push('      <edges>');
+        for (const edge of symbolMap.edges) {
+            out.push(`        <edge from="${escapeXmlAttr(edge.from)}" to="${escapeXmlAttr(edge.to)}" type="${escapeXmlAttr(edge.type)}" confidence="${escapeXmlAttr(edge.confidence)}" />`);
+        }
+        out.push('      </edges>');
+        out.push('    </symbol_map>');
+    }
+    out.push('  </manifest>');
+    return out;
+}
+function renderAnalysis(context) {
+    const out = [];
+    const ast = context.analysis?.ast;
+    if (!ast)
+        return out;
+    out.push('  <analysis>');
+    out.push('    <ast>');
+    if (ast.languageId) {
+        out.push(`      <language id="${escapeXmlAttr(ast.languageId)}" />`);
+    }
+    if (ast.parseError) {
+        out.push('      <parse_error>');
+        out.push(cdataBlock(truncateText(ast.parseError, ANALYSIS_LIMITS.maxParseErrorChars), '        '));
+        out.push('      </parse_error>');
+    }
+    if (Array.isArray(ast.syntaxErrors) && ast.syntaxErrors.length > 0) {
+        out.push('      <syntax_errors>');
+        for (const e of ast.syntaxErrors.slice(0, ANALYSIS_LIMITS.maxSyntaxErrors)) {
+            out.push(`        <error line="${e.line}" column="${e.column}" type="${escapeXmlAttr(e.type)}">`);
+            out.push(cdataBlock(e.text, '          '));
+            out.push('        </error>');
+        }
+        out.push('      </syntax_errors>');
+    }
+    if (Array.isArray(ast.notes) && ast.notes.length > 0) {
+        out.push('      <notes>');
+        for (const note of ast.notes.slice(0, ANALYSIS_LIMITS.maxNotes)) {
+            out.push('        <note>');
+            out.push(cdataBlock(truncateText(note, ANALYSIS_LIMITS.maxNoteChars), '          '));
+            out.push('        </note>');
+        }
+        out.push('      </notes>');
+    }
+    if (ast.controlFlow) {
+        out.push(`      <control_flow branches="${ast.controlFlow.branchCount}" loops="${ast.controlFlow.loopCount}" async_boundaries="${ast.controlFlow.asyncBoundaryCount}">`);
+        if (Array.isArray(ast.controlFlow.hotspots) && ast.controlFlow.hotspots.length > 0) {
+            out.push('        <hotspots>');
+            for (const hotspot of ast.controlFlow.hotspots) {
+                out.push(`          <hotspot type="${escapeXmlAttr(hotspot)}" />`);
+            }
+            out.push('        </hotspots>');
+        }
+        out.push('      </control_flow>');
+    }
+    if (ast.exceptionPaths) {
+        out.push(`      <exception_paths try_catch="${ast.exceptionPaths.tryCatchCount}" throws="${ast.exceptionPaths.throwCount}" promise_catch="${ast.exceptionPaths.promiseCatchCount}">`);
+        if (Array.isArray(ast.exceptionPaths.hotspots) && ast.exceptionPaths.hotspots.length > 0) {
+            out.push('        <hotspots>');
+            for (const hotspot of ast.exceptionPaths.hotspots) {
+                out.push(`          <hotspot type="${escapeXmlAttr(hotspot)}" />`);
+            }
+            out.push('        </hotspots>');
+        }
+        out.push('      </exception_paths>');
+    }
+    out.push('    </ast>');
+    out.push('  </analysis>');
+    return out;
+}
+function renderRelatedFiles(relatedFiles) {
+    const out = [];
+    if (!relatedFiles || relatedFiles.length === 0)
+        return out;
+    out.push('  <related_files>');
+    for (const file of relatedFiles) {
+        const reason = file.kind;
+        out.push(`    <file path="${escapeXmlAttr(file.path)}" reason="${escapeXmlAttr(reason)}" mode="${escapeXmlAttr(file.mode)}">`);
+        out.push(cdataBlock(file.content ?? '', '      '));
+        out.push('    </file>');
+    }
+    out.push('  </related_files>');
+    return out;
+}
+function renderSnippets(snippets) {
+    const out = [];
+    if (!snippets || snippets.length === 0)
+        return out;
+    out.push('  <code_snippets>');
+    for (const snippet of snippets) {
+        out.push(`    <snippet file="${escapeXmlAttr(normalizePath(snippet.file))}" line="${snippet.line}">`);
+        out.push(cdataBlock(snippet.content ?? '', '      '));
+        out.push('    </snippet>');
+    }
+    out.push('  </code_snippets>');
+    return out;
+}
+function renderDiffs(context) {
+    const out = [];
+    if (context.stagedDiff) {
+        out.push('  <staged_diff>');
+        out.push(cdataBlock(context.stagedDiff, '    '));
+        out.push('  </staged_diff>');
+    }
+    if (context.unstagedDiff) {
+        out.push('  <unstaged_diff>');
+        out.push(cdataBlock(context.unstagedDiff, '    '));
+        out.push('  </unstaged_diff>');
+    }
+    if (context.gitDiff && !context.stagedDiff && !context.unstagedDiff) {
+        out.push('  <git_diff>');
+        out.push(cdataBlock(context.gitDiff, '    '));
+        out.push('  </git_diff>');
+    }
+    if (context.untrackedDiff) {
+        out.push('  <untracked_diff>');
+        out.push(cdataBlock(context.untrackedDiff, '    '));
+        out.push('  </untracked_diff>');
+    }
+    return out;
+}
+function renderUntrackedFiles(files) {
+    const out = [];
+    if (!files || files.length === 0)
+        return out;
+    out.push('  <untracked_files>');
+    for (const file of files) {
+        out.push(`    <file path="${escapeXmlAttr(normalizePath(file))}" />`);
+    }
+    out.push('  </untracked_files>');
+    return out;
+}
+function renderMetadata(context) {
+    const out = [];
+    const meta = context.projectMetadata;
+    if (!meta)
+        return out;
+    out.push('  <project_metadata>');
+    if (meta.packageJson) {
+        out.push('    <package_json>');
+        out.push(cdataBlock(JSON.stringify(meta.packageJson, null, 2), '      '));
+        out.push('    </package_json>');
+    }
+    if (meta.readmeHeader) {
+        out.push('    <readme_header>');
+        out.push(cdataBlock(meta.readmeHeader, '      '));
+        out.push('    </readme_header>');
+    }
+    if (meta.aiInstructions) {
+        out.push('    <ai_instructions>');
+        out.push(cdataBlock(meta.aiInstructions, '      '));
+        out.push('    </ai_instructions>');
+    }
+    if (meta.configFiles && meta.configFiles.length > 0) {
+        out.push('    <config_files>');
+        for (const file of meta.configFiles) {
+            out.push(`      <file path="${escapeXmlAttr(file)}" />`);
+        }
+        out.push('    </config_files>');
+    }
+    out.push('  </project_metadata>');
+    return out;
+}
+function renderGitHistory(context) {
+    const out = [];
+    const history = context.gitHistory;
+    if (!history?.recentCommits)
+        return out;
+    out.push('  <git_history>');
+    out.push(cdataBlock(history.recentCommits, '    '));
+    out.push('  </git_history>');
+    return out;
+}
+export function formatContextForXmlPrompt(context) {
+    const out = [];
+    out.push('<context>');
+    out.push(...renderManifest(context));
+    out.push(...renderAnalysis(context));
+    out.push(...renderMetadata(context));
+    out.push(...renderGitHistory(context));
+    out.push(...renderPrimaryFile(context));
+    out.push(...renderRelatedFiles(context.relatedFiles));
+    out.push(...renderSnippets(context.rgSnippets));
+    out.push(...renderDiffs(context));
+    out.push(...renderUntrackedFiles(context.untrackedFiles));
+    out.push('</context>');
+    return out.join('\n');
+}
+//# sourceMappingURL=xml-context.js.map

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

@@ -0,0 +1,75 @@
+import { FileAdapter } from '../../adapters/fs/file-adapter.js';
+import { getLogger } from '../../observability/logger.js';
+import { safeJoin } from '../../utils/path.js';
+export class ArchitectureGatherer {
+    static INDEX_DIR = '.salmonloop/index';
+    static ARCH_FILE = 'architecture.json';
+    fileAdapter = new FileAdapter();
+    async gather(req) {
+        const { repoPath } = req;
+        const indexDir = safeJoin(repoPath, ArchitectureGatherer.INDEX_DIR);
+        const archFile = safeJoin(indexDir, ArchitectureGatherer.ARCH_FILE);
+        // Try reading from cache first
+        try {
+            const cached = await this.fileAdapter.readFile(archFile, 'utf-8');
+            const parsed = JSON.parse(cached);
+            // Simple cache validation: if it has modules, use it
+            if (parsed.modules && Array.isArray(parsed.modules)) {
+                return parsed;
+            }
+        }
+        catch {
+            // Cache miss or corrupted, proceed to scan
+        }
+        const topology = {
+            modules: [],
+            folderStructure: '',
+        };
+        const srcPath = safeJoin(repoPath, 'src');
+        try {
+            const srcEntries = await this.fileAdapter.readdirWithTypes(srcPath);
+            const moduleList = [];
+            for (const entry of srcEntries) {
+                if (entry.isDirectory()) {
+                    const name = entry.name;
+                    const role = this.estimateRole(name);
+                    topology.modules.push({
+                        name,
+                        path: `src/${name}`,
+                        estimatedRole: role,
+                    });
+                    moduleList.push(name);
+                }
+            }
+            // Basic folder structure: tree-like overview
+            topology.folderStructure = 'src/\n' + moduleList.map((m) => `  └── ${m}/`).join('\n');
+            // Persistence: save to cache
+            try {
+                await this.fileAdapter.mkdir(indexDir);
+                await this.fileAdapter.writeFile(archFile, JSON.stringify(topology, null, 2));
+            }
+            catch (e) {
+                getLogger().debug(`[ArchitectureGatherer] Failed to save cache: ${e}`);
+            }
+        }
+        catch (e) {
+            getLogger().debug(`[ArchitectureGatherer] Failed to scan src directory: ${e}`);
+            // Fallback if no src directory
+            return { modules: [] };
+        }
+        return topology;
+    }
+    estimateRole(name) {
+        const lower = name.toLowerCase();
+        if (lower.includes('core') || lower.includes('engine') || lower.includes('logic'))
+            return 'core';
+        if (lower.includes('adapter') || lower.includes('integration') || lower.includes('connector'))
+            return 'adapter';
+        if (lower.includes('cli') || lower.includes('commands') || lower.includes('interface'))
+            return 'cli';
+        if (lower.includes('util') || lower.includes('helper') || lower.includes('common'))
+            return 'util';
+        return 'other';
+    }
+}
+//# sourceMappingURL=architecture-gatherer.js.map

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

@@ -0,0 +1,53 @@
+import { createHash } from 'node:crypto';
+import { FileAdapter } from '../../adapters/fs/file-adapter.js';
+import { safeJoin } from '../../utils/path.js';
+export class ArtifactGatherer {
+    static COMMON_BUILD_DIRS = ['dist', 'build', 'out', 'target', 'bin'];
+    static CRITICAL_LOCK_FILES = [
+        'package-lock.json',
+        'bun.lock',
+        'pnpm-lock.yaml',
+        'yarn.lock',
+        'Cargo.lock',
+        'go.sum',
+        'requirements.txt',
+    ];
+    fileAdapter = new FileAdapter();
+    async gather(req) {
+        const { repoPath } = req;
+        const artifacts = {
+            buildDirs: [],
+            lockFiles: [],
+            envVars: [],
+        };
+        // 1. Detect Build Dirs
+        try {
+            const rootEntries = await this.fileAdapter.readdir(repoPath);
+            artifacts.buildDirs = rootEntries.filter((e) => ArtifactGatherer.COMMON_BUILD_DIRS.includes(e));
+        }
+        catch {
+            /* Ignore */
+        }
+        // 2. Lock Files & Hashes
+        for (const lock of ArtifactGatherer.CRITICAL_LOCK_FILES) {
+            try {
+                const lockPath = safeJoin(repoPath, lock);
+                const lockStat = await this.fileAdapter.stat(lockPath);
+                if (lockStat.isFile()) {
+                    // For large lock files, we only take a partial hash to be fast
+                    const content = await this.fileAdapter.readFile(lockPath, 'utf-8');
+                    const hash = createHash('md5').update(content.slice(0, 5000)).digest('hex');
+                    artifacts.lockFiles?.push({ path: lock, hash });
+                }
+            }
+            catch {
+                /* Ignore */
+            }
+        }
+        // 3. Selective Env Vars (Names only, no values for security)
+        const safeEnvPrefixes = ['NODE_', 'BUN_', 'JAVA_', 'PYTHON_', 'GO_', 'CI', 'DEBUG'];
+        artifacts.envVars = Object.keys(process.env).filter((key) => safeEnvPrefixes.some((p) => key.startsWith(p)));
+        return artifacts;
+    }
+}
+//# sourceMappingURL=artifact-gatherer.js.map