scalix 1.0.0 → 1.1.0

package/dist/context-retriever.js

@@ -0,0 +1,257 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { estimateTokens } from './token-counter.js';
+export const RETRIEVAL_DEFAULTS = {
+    enabled: true,
+    maxSnippets: 5,
+    maxTokensPerSnippet: 500,
+    maxTotalTokens: 3000,
+    previewLines: 30,
+    minRelevanceScore: 0.3,
+};
+const STOP_WORDS = new Set([
+    'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been',
+    'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'from',
+    'and', 'or', 'but', 'not', 'no', 'so', 'if', 'then', 'else',
+    'do', 'does', 'did', 'will', 'would', 'should', 'could', 'can',
+    'has', 'have', 'had', 'this', 'that', 'these', 'those',
+    'it', 'its', 'i', 'me', 'my', 'we', 'our', 'you', 'your',
+    'he', 'she', 'they', 'them', 'what', 'which', 'who', 'how',
+    'when', 'where', 'why', 'all', 'each', 'every', 'any', 'some',
+    'about', 'up', 'out', 'just', 'also', 'than', 'very',
+    'code', 'file', 'function', 'change', 'make', 'use', 'using',
+    'want', 'need', 'like', 'please', 'help', 'show', 'get',
+]);
+const FILE_HINT_RE = /(?:^|[\s`"'(])([.\w][\w./-]*\/[\w./-]+\.\w{1,10})(?=[\s`"'),.:;]|$)/gm;
+const CAMEL_RE = /\b([A-Z][a-zA-Z]{2,})\b/g;
+const SNAKE_RE = /\b([a-z][a-z0-9]*(?:_[a-z0-9]+){1,})\b/g;
+const INTENT_PATTERNS = {
+    debug: /\b(?:fix|debug|error|bug|broken|crash|fail|issue|wrong|problem)\b/i,
+    create: /\b(?:create|add|new|implement|build|generate|write|introduce)\b/i,
+    modify: /\b(?:change|update|modify|refactor|rename|move|replace|improve|optimize)\b/i,
+    explore: /\b(?:read|show|explain|understand|find|search|look|what|where|how|list|describe)\b/i,
+    general: /./,
+};
+export function analyzeQuery(query) {
+    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const keywords = words.filter((w) => !STOP_WORDS.has(w) && w.length > 2);
+    const fileHints = [];
+    for (const m of query.matchAll(FILE_HINT_RE)) {
+        fileHints.push(m[1]);
+    }
+    const symbolHints = [];
+    for (const m of query.matchAll(CAMEL_RE)) {
+        symbolHints.push(m[1]);
+    }
+    for (const m of query.matchAll(SNAKE_RE)) {
+        symbolHints.push(m[1]);
+    }
+    let intentType = 'general';
+    for (const [intent, re] of Object.entries(INTENT_PATTERNS)) {
+        if (intent === 'general')
+            continue;
+        if (re.test(query)) {
+            intentType = intent;
+            break;
+        }
+    }
+    return { keywords, fileHints, symbolHints, intentType };
+}
+function scoreFiles(analysis, index) {
+    const symbolsByFile = new Map();
+    for (const sym of index.symbols) {
+        const existing = symbolsByFile.get(sym.file) ?? [];
+        existing.push(sym);
+        symbolsByFile.set(sym.file, existing);
+    }
+    const importGraph = new Map();
+    for (const imp of index.imports) {
+        const deps = importGraph.get(imp.from) ?? new Set();
+        deps.add(imp.to);
+        importGraph.set(imp.from, deps);
+    }
+    const recentFiles = new Set(index.files
+        .sort((a, b) => b.modifiedAt - a.modifiedAt)
+        .slice(0, 20)
+        .map((f) => f.relativePath));
+    const directMentionFiles = new Set();
+    for (const hint of analysis.fileHints) {
+        for (const f of index.files) {
+            if (f.relativePath === hint || f.relativePath.endsWith(hint)) {
+                directMentionFiles.add(f.relativePath);
+            }
+        }
+    }
+    const scores = [];
+    for (const file of index.files) {
+        let score = 0;
+        const reasons = [];
+        const matchingSymbols = [];
+        // Direct file mention
+        if (directMentionFiles.has(file.relativePath)) {
+            score += 1.0;
+            reasons.push('directly mentioned');
+        }
+        // Symbol match
+        const fileSymbols = symbolsByFile.get(file.relativePath) ?? [];
+        for (const sym of fileSymbols) {
+            const nameLower = sym.name.toLowerCase();
+            if (analysis.symbolHints.some((h) => h.toLowerCase() === nameLower)) {
+                score += 0.6;
+                matchingSymbols.push(sym.name);
+                reasons.push(`symbol "${sym.name}"`);
+            }
+            else if (analysis.keywords.some((k) => nameLower.includes(k))) {
+                score += 0.3;
+                matchingSymbols.push(sym.name);
+                reasons.push(`keyword in symbol "${sym.name}"`);
+            }
+        }
+        // Import proximity — file is imported by a directly-mentioned file
+        for (const mentionedFile of directMentionFiles) {
+            const deps = importGraph.get(mentionedFile);
+            if (deps?.has(file.relativePath)) {
+                score += 0.3;
+                reasons.push(`imported by ${mentionedFile}`);
+            }
+        }
+        // Keyword in path
+        const pathLower = file.relativePath.toLowerCase();
+        for (const kw of analysis.keywords) {
+            if (pathLower.includes(kw)) {
+                score += 0.2;
+                reasons.push(`keyword "${kw}" in path`);
+            }
+        }
+        // Recency bonus
+        if (recentFiles.has(file.relativePath)) {
+            score += 0.1;
+            reasons.push('recently modified');
+        }
+        if (score > 0) {
+            scores.push({
+                file: file.relativePath,
+                score: Math.min(score, 2.0),
+                matchingSymbols,
+                reason: reasons.join(', '),
+            });
+        }
+    }
+    return scores.sort((a, b) => b.score - a.score);
+}
+async function generatePreview(filePath, projectRoot, matchingSymbols, maxLines) {
+    try {
+        const absPath = path.join(projectRoot, filePath);
+        const content = await fs.readFile(absPath, 'utf-8');
+        const lines = content.split('\n');
+        if (matchingSymbols.length > 0) {
+            // Show lines around matching symbols
+            const ranges = [];
+            for (const sym of matchingSymbols.slice(0, 3)) {
+                const start = Math.max(0, sym.line - 2);
+                const end = Math.min(lines.length - 1, sym.line + 8);
+                ranges.push([start, end]);
+            }
+            // Merge overlapping ranges
+            ranges.sort((a, b) => a[0] - b[0]);
+            const merged = [ranges[0]];
+            for (let i = 1; i < ranges.length; i++) {
+                const prev = merged[merged.length - 1];
+                if (ranges[i][0] <= prev[1] + 2) {
+                    prev[1] = Math.max(prev[1], ranges[i][1]);
+                }
+                else {
+                    merged.push(ranges[i]);
+                }
+            }
+            const parts = [];
+            let totalLines = 0;
+            for (const [start, end] of merged) {
+                if (totalLines >= maxLines)
+                    break;
+                const available = maxLines - totalLines;
+                const rangeEnd = Math.min(end, start + available - 1);
+                for (let i = start; i <= rangeEnd; i++) {
+                    parts.push(`${i + 1}\t${lines[i]}`);
+                    totalLines++;
+                }
+                if (rangeEnd < end)
+                    break;
+                parts.push('...');
+            }
+            return parts.join('\n');
+        }
+        // No matching symbols — show first N lines
+        return lines
+            .slice(0, maxLines)
+            .map((l, i) => `${i + 1}\t${l}`)
+            .join('\n');
+    }
+    catch {
+        return '(file could not be read)';
+    }
+}
+export async function retrieveContext(query, index, config = RETRIEVAL_DEFAULTS) {
+    const analysis = analyzeQuery(query);
+    if (analysis.keywords.length === 0 && analysis.fileHints.length === 0 && analysis.symbolHints.length === 0) {
+        return { snippets: [], totalTokens: 0, queryTerms: [] };
+    }
+    const scored = scoreFiles(analysis, index);
+    const candidates = scored.filter((s) => s.score >= config.minRelevanceScore).slice(0, config.maxSnippets);
+    const symbolsByFile = new Map();
+    for (const sym of index.symbols) {
+        const existing = symbolsByFile.get(sym.file) ?? [];
+        existing.push(sym);
+        symbolsByFile.set(sym.file, existing);
+    }
+    const snippets = [];
+    let totalTokens = 0;
+    for (const candidate of candidates) {
+        if (totalTokens >= config.maxTotalTokens)
+            break;
+        const matchingSymbols = (symbolsByFile.get(candidate.file) ?? [])
+            .filter((s) => candidate.matchingSymbols.includes(s.name));
+        const preview = await generatePreview(candidate.file, index.root, matchingSymbols, config.previewLines);
+        let tokens = estimateTokens(preview);
+        let truncatedPreview = preview;
+        if (tokens > config.maxTokensPerSnippet) {
+            const lines = preview.split('\n');
+            const kept = [];
+            let running = 0;
+            for (const line of lines) {
+                const lt = estimateTokens(line);
+                if (running + lt > config.maxTokensPerSnippet)
+                    break;
+                kept.push(line);
+                running += lt;
+            }
+            truncatedPreview = kept.join('\n');
+            tokens = running;
+        }
+        if (totalTokens + tokens > config.maxTotalTokens)
+            break;
+        snippets.push({
+            file: candidate.file,
+            relevanceScore: candidate.score,
+            symbols: candidate.matchingSymbols,
+            preview: truncatedPreview,
+            reason: candidate.reason,
+        });
+        totalTokens += tokens;
+    }
+    return { snippets, totalTokens, queryTerms: analysis.keywords };
+}
+export function snippetsToContext(snippets) {
+    if (snippets.length === 0)
+        return '';
+    const parts = ['## Relevant Code Context',
+        'The following file excerpts may be relevant. Use this as ground truth rather than guessing.\n'];
+    for (const s of snippets) {
+        const symbolStr = s.symbols.length > 0 ? `\nSymbols: ${s.symbols.join(', ')}` : '';
+        parts.push(`### ${s.file} (score: ${s.relevanceScore.toFixed(1)})${symbolStr}`);
+        parts.push('```');
+        parts.push(s.preview);
+        parts.push('```\n');
+    }
+    return parts.join('\n');
+}

package/dist/git-context.js

@@ -1,27 +1,30 @@
-import { execSync } from 'node:child_process';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
 import { TOOL_DEFAULTS, GIT_CONTEXT_DEFAULTS, PROJECT_INDEX_DEFAULTS } from './constants.js';
-function run(cmd, cwd) {
+const execAsync = promisify(exec);
+async function run(cmd, cwd) {
     try {
-        return execSync(cmd, { cwd, encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        const { stdout } = await execAsync(cmd, { cwd, encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs });
+        return stdout.trim();
     }
     catch {
         return '';
     }
 }
-function isGitRepo(cwd) {
-    return run('git rev-parse --is-inside-work-tree', cwd) === 'true';
+async function isGitRepo(cwd) {
+    return (await run('git rev-parse --is-inside-work-tree', cwd)) === 'true';
 }
-function getBranch(cwd) {
-    return run('git branch --show-current', cwd) || run('git rev-parse --short HEAD', cwd) || 'unknown';
+async function getBranch(cwd) {
+    return (await run('git branch --show-current', cwd)) || (await run('git rev-parse --short HEAD', cwd)) || 'unknown';
 }
-function getRemoteBranch(cwd) {
+async function getRemoteBranch(cwd) {
     return run('git rev-parse --abbrev-ref @{upstream} 2>/dev/null', cwd);
 }
-function getRemoteUrl(cwd) {
+async function getRemoteUrl(cwd) {
     return run('git remote get-url origin 2>/dev/null', cwd);
 }
-function getAheadBehind(cwd) {
-    const result = run('git rev-list --left-right --count @{upstream}...HEAD 2>/dev/null', cwd);
+async function getAheadBehind(cwd) {
+    const result = await run('git rev-list --left-right --count @{upstream}...HEAD 2>/dev/null', cwd);
     if (!result)
         return { ahead: 0, behind: 0 };
     const parts = result.split('\t');
@@ -29,12 +32,12 @@ function getAheadBehind(cwd) {
         return { ahead: 0, behind: 0 };
     return { ahead: Number(parts[1]) || 0, behind: Number(parts[0]) || 0 };
 }
-function getStashCount(cwd) {
-    const result = run('git stash list 2>/dev/null', cwd);
+async function getStashCount(cwd) {
+    const result = await run('git stash list 2>/dev/null', cwd);
     return result ? result.split('\n').filter(Boolean).length : 0;
 }
-function getStatus(cwd) {
-    const result = run('git status --porcelain', cwd);
+async function getStatus(cwd) {
+    const result = await run('git status --porcelain', cwd);
     if (!result)
         return [];
     return result.split('\n').filter(Boolean).map((line) => {
@@ -68,10 +71,10 @@ function getStatus(cwd) {
         return { path: filePath, status, staged };
     });
 }
-function getRecentCommits(cwd, count = GIT_CONTEXT_DEFAULTS.recentCommitsCount) {
+async function getRecentCommits(cwd, count = GIT_CONTEXT_DEFAULTS.recentCommitsCount) {
     const SEP = '<%>';
     const format = `%H${SEP}%h${SEP}%s${SEP}%an${SEP}%ar`;
-    const result = run(`git log --pretty=format:"${format}" --shortstat -n ${count} 2>/dev/null`, cwd);
+    const result = await run(`git log --pretty=format:"${format}" --shortstat -n ${count} 2>/dev/null`, cwd);
     if (!result)
         return [];
     const commits = [];
@@ -103,8 +106,8 @@ function getRecentCommits(cwd, count = GIT_CONTEXT_DEFAULTS.recentCommitsCount)
     }
     return commits;
 }
-export function collectGitInfo(cwd) {
-    if (!isGitRepo(cwd)) {
+export async function collectGitInfo(cwd) {
+    if (!(await isGitRepo(cwd))) {
         return {
             isRepo: false,
             branch: '',
@@ -116,16 +119,16 @@ export function collectGitInfo(cwd) {
             remoteUrl: '',
         };
     }
-    return {
-        isRepo: true,
-        branch: getBranch(cwd),
-        remoteBranch: getRemoteBranch(cwd),
-        status: getStatus(cwd),
-        recentCommits: getRecentCommits(cwd, GIT_CONTEXT_DEFAULTS.recentCommitsContextCount),
-        stashCount: getStashCount(cwd),
-        aheadBehind: getAheadBehind(cwd),
-        remoteUrl: getRemoteUrl(cwd),
-    };
+    const [branch, remoteBranch, status, recentCommits, stashCount, aheadBehind, remoteUrl] = await Promise.all([
+        getBranch(cwd),
+        getRemoteBranch(cwd),
+        getStatus(cwd),
+        getRecentCommits(cwd, GIT_CONTEXT_DEFAULTS.recentCommitsContextCount),
+        getStashCount(cwd),
+        getAheadBehind(cwd),
+        getRemoteUrl(cwd),
+    ]);
+    return { isRepo: true, branch, remoteBranch, status, recentCommits, stashCount, aheadBehind, remoteUrl };
 }
 export function gitInfoToContext(info) {
     if (!info.isRepo)

package/dist/grounding-checker.js

@@ -0,0 +1,154 @@
+export const GROUNDING_DEFAULTS = {
+    enabled: true,
+    maxNudges: 1,
+    ungroundedThreshold: 0.5,
+    minClaimsToCheck: 2,
+};
+const TRIVIAL_FILES = new Set([
+    'README.md', 'LICENSE', 'package.json', 'tsconfig.json',
+    'Cargo.toml', 'go.mod', 'Makefile', 'Dockerfile',
+    '.gitignore', '.env', '.env.example',
+]);
+const FILE_PATH_RE = /(?:^|[\s`"'(])([.\w][\w./-]*\/[\w./-]+\.\w{1,10})(?=[\s`"'),.:;]|$)/gm;
+const FUNC_CALL_RE = /\b([a-zA-Z_]\w{2,})\s*\(/g;
+const FUNC_DESC_RE = /\b(?:function|method|def|fn|func|handler|callback)\s+([a-zA-Z_]\w{2,})\b/gi;
+const CLASS_RE = /\b(?:class|interface|type|struct|enum|trait)\s+([A-Z]\w{2,})\b/g;
+const LINE_NUM_RE = /\b(?:line\s+|:)(\d{2,5})\b/gi;
+const IMPORT_RE = /(?:import|from|require)\s*\(?['"]([^'"]+)['"]\)?/g;
+function surroundingContext(text, pos, radius = 60) {
+    const start = Math.max(0, pos - radius);
+    const end = Math.min(text.length, pos + radius);
+    return text.slice(start, end).replace(/\n/g, ' ').trim();
+}
+export function extractCodeClaims(text) {
+    const seen = new Set();
+    const claims = [];
+    function add(type, value, position) {
+        const key = `${type}:${value}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        claims.push({ type, value, context: surroundingContext(text, position), position });
+    }
+    // File paths (must contain a / to avoid single-word matches)
+    for (const m of text.matchAll(FILE_PATH_RE)) {
+        const val = m[1];
+        const basename = val.split('/').pop() || val;
+        if (TRIVIAL_FILES.has(basename) || TRIVIAL_FILES.has(val))
+            continue;
+        add('file_path', val, m.index + m[0].indexOf(val));
+    }
+    // Function calls — foo()
+    for (const m of text.matchAll(FUNC_CALL_RE)) {
+        const name = m[1];
+        if (name.length > 50 || /^(if|for|while|switch|return|new|typeof|catch|throw|await|async|const|let|var|function|class|import|export|from|this|self|true|false|null|undefined|console|process|require|module)$/.test(name))
+            continue;
+        add('function_name', name, m.index);
+    }
+    // Function descriptions — "the handleSubmit function"
+    for (const m of text.matchAll(FUNC_DESC_RE)) {
+        add('function_name', m[1], m.index);
+    }
+    // Class/interface/type names
+    for (const m of text.matchAll(CLASS_RE)) {
+        if (m[1].length > 50)
+            continue;
+        add('class_name', m[1], m.index);
+    }
+    // Line numbers (only >9 to avoid trivial matches)
+    for (const m of text.matchAll(LINE_NUM_RE)) {
+        const num = parseInt(m[1], 10);
+        if (num < 10)
+            continue;
+        add('line_number', m[1], m.index);
+    }
+    // Import references
+    for (const m of text.matchAll(IMPORT_RE)) {
+        if (m[1].startsWith('.')) {
+            add('import', m[1], m.index);
+        }
+    }
+    return claims;
+}
+function buildGroundingCorpus(messages) {
+    const parts = [];
+    for (const m of messages) {
+        if (m.role === 'tool' && m.content) {
+            parts.push(typeof m.content === 'string' ? m.content : JSON.stringify(m.content));
+        }
+        if (m.role === 'assistant' && m.tool_calls) {
+            for (const tc of m.tool_calls) {
+                parts.push(tc.function.arguments);
+            }
+        }
+    }
+    return parts.join('\n');
+}
+export function checkGrounding(claims, messages, threshold = GROUNDING_DEFAULTS.ungroundedThreshold, minClaims = GROUNDING_DEFAULTS.minClaimsToCheck) {
+    if (claims.length === 0) {
+        return { claims, groundedClaims: [], ungroundedClaims: [], groundingRatio: 1, needsVerification: false };
+    }
+    const corpus = buildGroundingCorpus(messages);
+    const corpusLower = corpus.toLowerCase();
+    const grounded = [];
+    const ungrounded = [];
+    for (const claim of claims) {
+        let found = false;
+        switch (claim.type) {
+            case 'file_path': {
+                if (corpus.includes(claim.value)) {
+                    found = true;
+                }
+                else {
+                    const basename = claim.value.split('/').pop();
+                    if (corpus.includes(basename))
+                        found = true;
+                }
+                break;
+            }
+            case 'function_name':
+            case 'class_name':
+            case 'variable_name': {
+                found = corpus.includes(claim.value);
+                break;
+            }
+            case 'line_number': {
+                const escaped = claim.value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                const linePattern = new RegExp(`(?:^|\\n)\\s*${escaped}\\t|:${escaped}[:\\s]`, 'm');
+                found = linePattern.test(corpus);
+                break;
+            }
+            case 'import': {
+                found = corpus.includes(claim.value);
+                break;
+            }
+            default:
+                found = corpusLower.includes(claim.value.toLowerCase());
+        }
+        if (found)
+            grounded.push(claim);
+        else
+            ungrounded.push(claim);
+    }
+    const ratio = grounded.length / claims.length;
+    const needsVerification = ratio < threshold && ungrounded.length >= minClaims;
+    return { claims, groundedClaims: grounded, ungroundedClaims: ungrounded, groundingRatio: ratio, needsVerification };
+}
+export function formatGroundingNudge(result) {
+    const items = result.ungroundedClaims.slice(0, 5).map((c) => {
+        switch (c.type) {
+            case 'file_path': return `- File "${c.value}" (not read in this conversation)`;
+            case 'function_name': return `- Function "${c.value}" (not seen in any tool output)`;
+            case 'class_name': return `- Type/class "${c.value}" (not seen in any tool output)`;
+            case 'line_number': return `- Line ${c.value} (not verified by reading the file)`;
+            case 'import': return `- Import "${c.value}" (not verified)`;
+            default: return `- "${c.value}" (not verified)`;
+        }
+    });
+    return [
+        '[GROUNDING CHECK] Your response references code elements that were not verified by reading the actual source:',
+        ...items,
+        'Please use read_file, search_files, or find_files to verify these references before presenting them as facts.',
+        'If you are uncertain about a path or name, say so explicitly rather than guessing.',
+    ].join('\n');
+}