scalix 0.0.1 → 1.1.0

package/dist/git-context.js

@@ -0,0 +1,183 @@
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { TOOL_DEFAULTS, GIT_CONTEXT_DEFAULTS, PROJECT_INDEX_DEFAULTS } from './constants.js';
+const execAsync = promisify(exec);
+async function run(cmd, cwd) {
+    try {
+        const { stdout } = await execAsync(cmd, { cwd, encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs });
+        return stdout.trim();
+    }
+    catch {
+        return '';
+    }
+}
+async function isGitRepo(cwd) {
+    return (await run('git rev-parse --is-inside-work-tree', cwd)) === 'true';
+}
+async function getBranch(cwd) {
+    return (await run('git branch --show-current', cwd)) || (await run('git rev-parse --short HEAD', cwd)) || 'unknown';
+}
+async function getRemoteBranch(cwd) {
+    return run('git rev-parse --abbrev-ref @{upstream} 2>/dev/null', cwd);
+}
+async function getRemoteUrl(cwd) {
+    return run('git remote get-url origin 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');
+    if (parts.length < 2)
+        return { ahead: 0, behind: 0 };
+    return { ahead: Number(parts[1]) || 0, behind: Number(parts[0]) || 0 };
+}
+async function getStashCount(cwd) {
+    const result = await run('git stash list 2>/dev/null', cwd);
+    return result ? result.split('\n').filter(Boolean).length : 0;
+}
+async function getStatus(cwd) {
+    const result = await run('git status --porcelain', cwd);
+    if (!result)
+        return [];
+    return result.split('\n').filter(Boolean).map((line) => {
+        const indexStatus = line[0];
+        const workStatus = line[1];
+        const filePath = line.slice(3).trim();
+        let status = 'modified';
+        let staged = false;
+        if (indexStatus === '?' && workStatus === '?') {
+            status = 'untracked';
+        }
+        else if (indexStatus === 'A') {
+            status = 'added';
+            staged = true;
+        }
+        else if (indexStatus === 'D' || workStatus === 'D') {
+            status = 'deleted';
+            staged = indexStatus === 'D';
+        }
+        else if (indexStatus === 'R') {
+            status = 'renamed';
+            staged = true;
+        }
+        else if (indexStatus === 'M') {
+            status = 'staged';
+            staged = true;
+        }
+        else if (workStatus === 'M') {
+            status = 'modified';
+        }
+        return { path: filePath, status, staged };
+    });
+}
+async function getRecentCommits(cwd, count = GIT_CONTEXT_DEFAULTS.recentCommitsCount) {
+    const SEP = '<%>';
+    const format = `%H${SEP}%h${SEP}%s${SEP}%an${SEP}%ar`;
+    const result = await run(`git log --pretty=format:"${format}" --shortstat -n ${count} 2>/dev/null`, cwd);
+    if (!result)
+        return [];
+    const commits = [];
+    const lines = result.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i].replace(/^"/, '').replace(/"$/, '');
+        const parts = line.split(SEP);
+        if (parts.length >= 5 && parts[0].length === 40) {
+            let filesChanged = 0;
+            if (i + 1 < lines.length && lines[i + 1].includes('file')) {
+                const match = lines[i + 1].match(/(\d+)\s+file/);
+                if (match)
+                    filesChanged = parseInt(match[1], 10);
+                i++;
+            }
+            if (i + 1 < lines.length && lines[i + 1].trim() === '')
+                i++;
+            commits.push({
+                hash: parts[0],
+                shortHash: parts[1],
+                message: parts[2],
+                author: parts[3],
+                date: parts[4],
+                filesChanged,
+            });
+        }
+        i++;
+    }
+    return commits;
+}
+export async function collectGitInfo(cwd) {
+    if (!(await isGitRepo(cwd))) {
+        return {
+            isRepo: false,
+            branch: '',
+            remoteBranch: '',
+            status: [],
+            recentCommits: [],
+            stashCount: 0,
+            aheadBehind: { ahead: 0, behind: 0 },
+            remoteUrl: '',
+        };
+    }
+    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)
+        return '## Git: Not a git repository';
+    const lines = ['## Git Context'];
+    lines.push(`Branch: ${info.branch}`);
+    if (info.remoteBranch) {
+        lines.push(`Tracking: ${info.remoteBranch}`);
+    }
+    const { ahead, behind } = info.aheadBehind;
+    if (ahead > 0 || behind > 0) {
+        const parts = [];
+        if (ahead > 0)
+            parts.push(`${ahead} ahead`);
+        if (behind > 0)
+            parts.push(`${behind} behind`);
+        lines.push(`Status: ${parts.join(', ')}`);
+    }
+    if (info.stashCount > 0) {
+        lines.push(`Stashes: ${info.stashCount}`);
+    }
+    if (info.status.length > 0) {
+        lines.push('');
+        lines.push('### Working Tree Changes');
+        const staged = info.status.filter((s) => s.staged);
+        const unstaged = info.status.filter((s) => !s.staged);
+        if (staged.length > 0) {
+            lines.push('Staged:');
+            for (const f of staged.slice(0, PROJECT_INDEX_DEFAULTS.statusDisplayLimit)) {
+                lines.push(`  ${f.status.padEnd(10)} ${f.path}`);
+            }
+            if (staged.length > PROJECT_INDEX_DEFAULTS.statusDisplayLimit)
+                lines.push(`  ... and ${staged.length - PROJECT_INDEX_DEFAULTS.statusDisplayLimit} more`);
+        }
+        if (unstaged.length > 0) {
+            lines.push('Unstaged:');
+            for (const f of unstaged.slice(0, PROJECT_INDEX_DEFAULTS.statusDisplayLimit)) {
+                lines.push(`  ${f.status.padEnd(10)} ${f.path}`);
+            }
+            if (unstaged.length > PROJECT_INDEX_DEFAULTS.statusDisplayLimit)
+                lines.push(`  ... and ${unstaged.length - PROJECT_INDEX_DEFAULTS.statusDisplayLimit} more`);
+        }
+    }
+    if (info.recentCommits.length > 0) {
+        lines.push('');
+        lines.push('### Recent Commits');
+        for (const c of info.recentCommits) {
+            lines.push(`  ${c.shortHash} ${c.message} (${c.author}, ${c.date})`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/git-undo.js

@@ -0,0 +1,67 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { logger } from './logger.js';
+import { TOOL_DEFAULTS } from './constants.js';
+const execFileAsync = promisify(execFile);
+async function git(args, cwd) {
+    const { stdout } = await execFileAsync('git', args, { cwd, timeout: TOOL_DEFAULTS.gitTimeoutMs });
+    return stdout.trim();
+}
+async function isGitRepo(cwd) {
+    try {
+        await git(['rev-parse', '--is-inside-work-tree'], cwd);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function hasChanges(cwd) {
+    const status = await git(['status', '--porcelain'], cwd);
+    return status.length > 0;
+}
+export async function createCheckpoint(cwd, label) {
+    if (!await isGitRepo(cwd))
+        return null;
+    if (!await hasChanges(cwd))
+        return null;
+    try {
+        await git(['add', '-u'], cwd);
+        const msg = `[scalix checkpoint] ${label || 'auto'}`;
+        await git(['commit', '-m', msg], cwd);
+        const hash = await git(['rev-parse', '--short', 'HEAD'], cwd);
+        logger.info('Checkpoint created', { hash, label });
+        return hash;
+    }
+    catch (err) {
+        logger.warn('Checkpoint failed', { error: err.message });
+        return null;
+    }
+}
+export async function undoLastCheckpoint(cwd) {
+    if (!await isGitRepo(cwd)) {
+        return { success: false, message: 'Not a git repository.' };
+    }
+    try {
+        const lastMsg = await git(['log', '-1', '--format=%s'], cwd);
+        if (!lastMsg.startsWith('[scalix checkpoint]')) {
+            return { success: false, message: 'Last commit is not a scalix checkpoint. Undo only works on agent-created commits.' };
+        }
+        await git(['reset', '--mixed', 'HEAD~1'], cwd);
+        return { success: true, message: `Undid checkpoint: ${lastMsg}` };
+    }
+    catch (err) {
+        return { success: false, message: `Undo failed: ${err.message}` };
+    }
+}
+export async function listCheckpoints(cwd, limit = 10) {
+    if (!await isGitRepo(cwd))
+        return [];
+    try {
+        const log = await git(['log', `--max-count=${limit}`, '--format=%h %s', '--grep=\\[scalix checkpoint\\]'], cwd);
+        return log ? log.split('\n') : [];
+    }
+    catch {
+        return [];
+    }
+}

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');
+}