scalix 0.0.1 → 1.0.0

package/dist/context-manager.js

@@ -0,0 +1,148 @@
+import { messageContentToString } from './agent.js';
+import { estimateTokens, estimateMessageTokens as _estimateMessageTokens } from './token-counter.js';
+import { CONTEXT_DEFAULTS, COMPRESSION_DEFAULTS } from './constants.js';
+export { estimateTokens };
+export function estimateMessageTokens(messages) {
+    return _estimateMessageTokens(messages);
+}
+export class ContextManager {
+    maxContextTokens;
+    compressionThreshold;
+    minRecentMessages;
+    maxToolResultTokens;
+    charsPerToken;
+    slidingWindowTarget;
+    constructor(config) {
+        this.maxContextTokens = config?.maxContextTokens ?? CONTEXT_DEFAULTS.maxContextTokens;
+        this.compressionThreshold = config?.compressionThreshold ?? CONTEXT_DEFAULTS.compressionThreshold;
+        this.minRecentMessages = config?.minRecentMessages ?? CONTEXT_DEFAULTS.minRecentMessages;
+        this.maxToolResultTokens = config?.maxToolResultTokens ?? CONTEXT_DEFAULTS.maxToolResultTokens;
+        this.charsPerToken = config?.charsPerToken ?? CONTEXT_DEFAULTS.charsPerToken;
+        this.slidingWindowTarget = config?.slidingWindowTarget ?? CONTEXT_DEFAULTS.slidingWindowTarget;
+    }
+    setMaxContextTokens(tokens) {
+        if (tokens > 0)
+            this.maxContextTokens = tokens;
+    }
+    shouldCompress(messages) {
+        const tokens = estimateMessageTokens(messages);
+        return tokens > this.maxContextTokens * this.compressionThreshold;
+    }
+    getTokenUsage(messages) {
+        const tokens = estimateMessageTokens(messages);
+        return {
+            tokens,
+            maxTokens: this.maxContextTokens,
+            percentage: Math.round((tokens / this.maxContextTokens) * 100),
+        };
+    }
+    truncateToolResults(messages) {
+        const maxChars = this.maxToolResultTokens * this.charsPerToken;
+        return messages.map((msg) => {
+            if (msg.role !== 'tool' || !msg.content)
+                return msg;
+            const text = messageContentToString(msg.content);
+            const tokens = estimateTokens(text);
+            if (tokens <= this.maxToolResultTokens)
+                return msg;
+            let cutoff = Math.floor(maxChars);
+            while (cutoff > 0 && text.charCodeAt(cutoff) >= 0xDC00 && text.charCodeAt(cutoff) <= 0xDFFF) {
+                cutoff--;
+            }
+            const truncated = text.slice(0, cutoff) +
+                '\n\n...[truncated — ' + (tokens - this.maxToolResultTokens) + ' tokens removed]';
+            return { ...msg, content: truncated };
+        });
+    }
+    splitForCompression(messages) {
+        if (messages.length <= this.minRecentMessages) {
+            return { toCompress: [], toKeep: [...messages] };
+        }
+        const keepCount = Math.max(this.minRecentMessages, Math.floor(messages.length * COMPRESSION_DEFAULTS.keepRatio));
+        let splitIndex = messages.length - keepCount;
+        // Walk backwards to avoid splitting tool-call/result pairs
+        while (splitIndex > 0) {
+            const msg = messages[splitIndex];
+            if (msg.role === 'tool') {
+                splitIndex--;
+                if (splitIndex > 0 && messages[splitIndex]?.role === 'assistant' && messages[splitIndex]?.tool_calls) {
+                    splitIndex--;
+                }
+            }
+            else {
+                break;
+            }
+        }
+        splitIndex = Math.max(0, splitIndex);
+        return {
+            toCompress: messages.slice(0, splitIndex),
+            toKeep: messages.slice(splitIndex),
+        };
+    }
+    buildCompressionPrompt(messages) {
+        const maxPerMessage = 4000;
+        const formatted = messages.map((m) => {
+            let line = `[${m.role}]`;
+            if (m.name)
+                line += ` (${m.name})`;
+            if (m.content) {
+                const text = messageContentToString(m.content);
+                const display = text.length > maxPerMessage
+                    ? text.slice(0, maxPerMessage) + `\n...[${text.length - maxPerMessage} chars omitted]`
+                    : text;
+                line += `: ${display}`;
+            }
+            if (m.tool_calls) {
+                const calls = m.tool_calls.map((tc) => {
+                    const args = tc.function.arguments;
+                    const preview = args.length > 200 ? args.slice(0, 200) + '...' : args;
+                    return `${tc.function.name}(${preview})`;
+                });
+                line += `: called ${calls.join(', ')}`;
+            }
+            return line;
+        }).join('\n');
+        return `You are compressing a conversation to fit within the context window. The compressed output will REPLACE the original messages — anything you omit is permanently lost.
+
+MUST PRESERVE (verbatim where possible):
+1. The user's goal — what they are trying to accomplish and why
+2. Every file path, function name, and line number mentioned
+3. Every error message, stack trace, and fix applied
+4. What was tried, what worked, what failed, and why
+5. The user's explicit preferences, corrections, and instructions
+6. Pending/incomplete work and next steps
+7. Key code snippets, commands run, and their results
+8. Configuration values, environment details, model names
+
+DO NOT preserve greetings, acknowledgments, thinking-out-loud, or redundant explanations.
+
+Conversation to compress:
+${formatted}
+
+Write a detailed, factual summary. Use specific names, paths, and values — not vague references. This summary is the agent's only memory of this work:`;
+    }
+    applySlidingWindow(messages) {
+        const usage = this.getTokenUsage(messages);
+        if (usage.percentage < 95)
+            return messages;
+        const target = this.maxContextTokens * this.slidingWindowTarget;
+        const result = [...messages];
+        while (estimateMessageTokens(result) > target && result.length > this.minRecentMessages) {
+            const removed = result.shift();
+            // Remove orphaned tool results: if we removed an assistant with tool_calls,
+            // also remove its paired tool results
+            if (removed?.role === 'assistant' && removed.tool_calls) {
+                const toolCallIds = new Set(removed.tool_calls.map((tc) => tc.id));
+                while (result.length > 0 && result[0]?.role === 'tool' && result[0]?.tool_call_id && toolCallIds.has(result[0].tool_call_id)) {
+                    result.shift();
+                }
+            }
+            // If we're about to leave orphaned tool results at the front (their assistant was already removed),
+            // clean them up
+            while (result.length > 0 && result[0]?.role === 'tool') {
+                result.shift();
+            }
+        }
+        return result;
+    }
+}

package/dist/cost-tracker.js

@@ -0,0 +1,85 @@
+export class CostTracker {
+    entries = [];
+    sessionStart = Date.now();
+    record(model, usage) {
+        this.entries.push({
+            model,
+            promptTokens: usage.prompt_tokens ?? 0,
+            completionTokens: usage.completion_tokens ?? 0,
+            totalTokens: usage.total_tokens ?? 0,
+            cost: usage.cost ?? 0,
+            timestamp: Date.now(),
+        });
+    }
+    get totalTokens() {
+        return this.entries.reduce((s, e) => s + e.totalTokens, 0);
+    }
+    get totalCost() {
+        return this.entries.reduce((s, e) => s + e.cost, 0);
+    }
+    get promptTokens() {
+        return this.entries.reduce((s, e) => s + e.promptTokens, 0);
+    }
+    get completionTokens() {
+        return this.entries.reduce((s, e) => s + e.completionTokens, 0);
+    }
+    get requestCount() {
+        return this.entries.length;
+    }
+    get sessionDuration() {
+        const s = Math.floor((Date.now() - this.sessionStart) / 1000);
+        if (s < 60)
+            return `${s}s`;
+        if (s < 3600)
+            return `${Math.floor(s / 60)}m${s % 60}s`;
+        return `${Math.floor(s / 3600)}h${Math.floor((s % 3600) / 60)}m`;
+    }
+    summary() {
+        const lines = [
+            `Session: ${this.sessionDuration} | ${this.requestCount} requests`,
+            `Tokens: ${this.totalTokens.toLocaleString()} (${this.promptTokens.toLocaleString()} prompt + ${this.completionTokens.toLocaleString()} completion)`,
+        ];
+        const byModel = new Map();
+        for (const e of this.entries) {
+            if (e.model === '(previous session)')
+                continue;
+            const prev = byModel.get(e.model) ?? { tokens: 0, count: 0 };
+            byModel.set(e.model, { tokens: prev.tokens + e.totalTokens, count: prev.count + 1 });
+        }
+        if (byModel.size > 0) {
+            lines.push('By model:');
+            for (const [model, stats] of byModel) {
+                const short = model.split('/').pop()?.replace(/:free$/, '') ?? model;
+                lines.push(`  ${short}: ${stats.tokens.toLocaleString()} tokens (${stats.count} reqs)`);
+            }
+        }
+        return lines.join('\n');
+    }
+    reset() {
+        this.entries = [];
+        this.sessionStart = Date.now();
+    }
+    restore(state) {
+        this.entries = [];
+        if (state.requestCount > 0 && state.totalTokens >= 0) {
+            const count = Math.max(1, state.requestCount);
+            const perReqTokens = Math.floor(state.totalTokens / count);
+            const remainder = state.totalTokens - perReqTokens * count;
+            const perReqCost = state.totalCost / count;
+            for (let i = 0; i < count; i++) {
+                this.entries.push({
+                    model: '(previous session)',
+                    promptTokens: 0,
+                    completionTokens: 0,
+                    totalTokens: perReqTokens + (i === 0 ? remainder : 0),
+                    cost: perReqCost,
+                    timestamp: Date.now(),
+                });
+            }
+        }
+    }
+    getState() {
+        return { totalTokens: this.totalTokens, totalCost: this.totalCost, requestCount: this.requestCount };
+    }
+}
+export const costTracker = new CostTracker();

package/dist/diff.js

@@ -0,0 +1,140 @@
+function lcsLengths(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] + 1 : Math.max(dp[i - 1][j], dp[i][j - 1]);
+        }
+    }
+    return dp;
+}
+function backtrack(dp, a, b) {
+    const lines = [];
+    let i = a.length;
+    let j = b.length;
+    while (i > 0 || j > 0) {
+        if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) {
+            lines.push({ type: 'context', lineOld: i, lineNew: j, text: a[i - 1] });
+            i--;
+            j--;
+        }
+        else if (j > 0 && (i === 0 || dp[i][j - 1] > dp[i - 1][j])) {
+            lines.push({ type: 'add', lineNew: j, text: b[j - 1] });
+            j--;
+        }
+        else {
+            lines.push({ type: 'remove', lineOld: i, text: a[i - 1] });
+            i--;
+        }
+    }
+    return lines.reverse();
+}
+const LARGE_FILE_THRESHOLD = 50_000;
+function simpleDiff(oldLines, newLines) {
+    const lines = [];
+    const oldSet = new Map();
+    oldLines.forEach((l, i) => {
+        if (!oldSet.has(l))
+            oldSet.set(l, []);
+        oldSet.get(l).push(i + 1);
+    });
+    let commonPrefix = 0;
+    while (commonPrefix < oldLines.length && commonPrefix < newLines.length && oldLines[commonPrefix] === newLines[commonPrefix]) {
+        lines.push({ type: 'context', lineOld: commonPrefix + 1, lineNew: commonPrefix + 1, text: oldLines[commonPrefix] });
+        commonPrefix++;
+    }
+    let commonSuffix = 0;
+    while (commonSuffix < oldLines.length - commonPrefix &&
+        commonSuffix < newLines.length - commonPrefix &&
+        oldLines[oldLines.length - 1 - commonSuffix] === newLines[newLines.length - 1 - commonSuffix]) {
+        commonSuffix++;
+    }
+    for (let i = commonPrefix; i < oldLines.length - commonSuffix; i++) {
+        lines.push({ type: 'remove', lineOld: i + 1, text: oldLines[i] });
+    }
+    for (let i = commonPrefix; i < newLines.length - commonSuffix; i++) {
+        lines.push({ type: 'add', lineNew: i + 1, text: newLines[i] });
+    }
+    for (let s = commonSuffix - 1; s >= 0; s--) {
+        const oldIdx = oldLines.length - 1 - s;
+        const newIdx = newLines.length - 1 - s;
+        lines.push({ type: 'context', lineOld: oldIdx + 1, lineNew: newIdx + 1, text: oldLines[oldIdx] });
+    }
+    return lines;
+}
+export function computeDiff(oldText, newText) {
+    if (oldText === newText)
+        return { hunks: [], additions: 0, deletions: 0 };
+    const oldLines = oldText === '' ? [] : oldText.split('\n');
+    const newLines = newText === '' ? [] : newText.split('\n');
+    const isLarge = oldLines.length > LARGE_FILE_THRESHOLD || newLines.length > LARGE_FILE_THRESHOLD;
+    const allLines = isLarge
+        ? simpleDiff(oldLines, newLines)
+        : backtrack(lcsLengths(oldLines, newLines), oldLines, newLines);
+    const hunks = [];
+    let currentHunk = [];
+    let contextCount = 0;
+    const CONTEXT_SIZE = 3;
+    for (let idx = 0; idx < allLines.length; idx++) {
+        const line = allLines[idx];
+        if (line.type === 'context') {
+            contextCount++;
+            if (currentHunk.length > 0 && contextCount > CONTEXT_SIZE * 2) {
+                hunks.push(currentHunk);
+                currentHunk = [];
+                contextCount = 1;
+            }
+            if (currentHunk.length > 0 || contextCount <= CONTEXT_SIZE) {
+                currentHunk.push(line);
+            }
+        }
+        else {
+            if (contextCount > CONTEXT_SIZE && currentHunk.length === 0) {
+                for (let k = Math.max(0, idx - CONTEXT_SIZE); k < idx; k++) {
+                    if (allLines[k].type === 'context')
+                        currentHunk.push(allLines[k]);
+                }
+            }
+            currentHunk.push(line);
+            contextCount = 0;
+        }
+    }
+    if (currentHunk.some((l) => l.type !== 'context')) {
+        hunks.push(currentHunk);
+    }
+    const additions = allLines.filter((l) => l.type === 'add').length;
+    const deletions = allLines.filter((l) => l.type === 'remove').length;
+    return { hunks, additions, deletions };
+}
+export function formatDiff(diff, filePath) {
+    if (diff.hunks.length === 0)
+        return '(no changes)';
+    const lines = [];
+    if (filePath) {
+        lines.push(`--- ${filePath}`);
+        lines.push(`+++ ${filePath}`);
+    }
+    for (const hunk of diff.hunks) {
+        const firstOld = hunk.find((l) => l.lineOld)?.lineOld ?? 1;
+        const firstNew = hunk.find((l) => l.lineNew)?.lineNew ?? 1;
+        const oldCount = hunk.filter((l) => l.type !== 'add').length;
+        const newCount = hunk.filter((l) => l.type !== 'remove').length;
+        lines.push(`@@ -${firstOld},${oldCount} +${firstNew},${newCount} @@`);
+        for (const line of hunk) {
+            switch (line.type) {
+                case 'add':
+                    lines.push(`\x1b[32m+ ${line.text}\x1b[0m`);
+                    break;
+                case 'remove':
+                    lines.push(`\x1b[31m- ${line.text}\x1b[0m`);
+                    break;
+                case 'context':
+                    lines.push(`  ${line.text}`);
+                    break;
+            }
+        }
+    }
+    lines.push(`\x1b[36m${diff.additions} additions, ${diff.deletions} deletions\x1b[0m`);
+    return lines.join('\n');
+}

package/dist/git-context.js

@@ -0,0 +1,180 @@
+import { execSync } from 'node:child_process';
+import { TOOL_DEFAULTS, GIT_CONTEXT_DEFAULTS, PROJECT_INDEX_DEFAULTS } from './constants.js';
+function run(cmd, cwd) {
+    try {
+        return execSync(cmd, { cwd, encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+function isGitRepo(cwd) {
+    return 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';
+}
+function getRemoteBranch(cwd) {
+    return run('git rev-parse --abbrev-ref @{upstream} 2>/dev/null', cwd);
+}
+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);
+    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 };
+}
+function getStashCount(cwd) {
+    const result = 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);
+    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 };
+    });
+}
+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);
+    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 function collectGitInfo(cwd) {
+    if (!isGitRepo(cwd)) {
+        return {
+            isRepo: false,
+            branch: '',
+            remoteBranch: '',
+            status: [],
+            recentCommits: [],
+            stashCount: 0,
+            aheadBehind: { ahead: 0, behind: 0 },
+            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),
+    };
+}
+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 [];
+    }
+}