shortcutxl 0.2.0

package/dist/core/compaction/utils.js

@@ -0,0 +1,139 @@
+/**
+ * Shared utilities for compaction and branch summarization.
+ */
+import { EDIT, READ, WRITE } from '../../tool-names.js';
+export function createFileOps() {
+    return {
+        read: new Set(),
+        written: new Set(),
+        edited: new Set()
+    };
+}
+/**
+ * Extract file operations from tool calls in an assistant message.
+ */
+export function extractFileOpsFromMessage(message, fileOps) {
+    if (message.role !== 'assistant')
+        return;
+    if (!('content' in message) || !Array.isArray(message.content))
+        return;
+    for (const block of message.content) {
+        if (typeof block !== 'object' || block === null)
+            continue;
+        if (!('type' in block) || block.type !== 'toolCall')
+            continue;
+        if (!('arguments' in block) || !('name' in block))
+            continue;
+        const args = block.arguments;
+        if (!args)
+            continue;
+        const path = typeof args.path === 'string' ? args.path : undefined;
+        if (!path)
+            continue;
+        switch (block.name) {
+            case READ:
+                fileOps.read.add(path);
+                break;
+            case WRITE:
+                fileOps.written.add(path);
+                break;
+            case EDIT:
+                fileOps.edited.add(path);
+                break;
+        }
+    }
+}
+/**
+ * Compute final file lists from file operations.
+ * Returns readFiles (files only read, not modified) and modifiedFiles.
+ */
+export function computeFileLists(fileOps) {
+    const modified = new Set([...fileOps.edited, ...fileOps.written]);
+    const readOnly = [...fileOps.read].filter((f) => !modified.has(f)).sort();
+    const modifiedFiles = [...modified].sort();
+    return { readFiles: readOnly, modifiedFiles };
+}
+/**
+ * Format file operations as XML tags for summary.
+ */
+export function formatFileOperations(readFiles, modifiedFiles) {
+    const sections = [];
+    if (readFiles.length > 0) {
+        sections.push(`<read-files>\n${readFiles.join('\n')}\n</read-files>`);
+    }
+    if (modifiedFiles.length > 0) {
+        sections.push(`<modified-files>\n${modifiedFiles.join('\n')}\n</modified-files>`);
+    }
+    if (sections.length === 0)
+        return '';
+    return `\n\n${sections.join('\n\n')}`;
+}
+// ============================================================================
+// Message Serialization
+// ============================================================================
+/**
+ * Serialize LLM messages to text for summarization.
+ * This prevents the model from treating it as a conversation to continue.
+ * Call convertToLlm() first to handle custom message types.
+ */
+export function serializeConversation(messages) {
+    const parts = [];
+    for (const msg of messages) {
+        if (msg.role === 'user') {
+            const content = typeof msg.content === 'string'
+                ? msg.content
+                : msg.content
+                    .filter((c) => c.type === 'text')
+                    .map((c) => c.text)
+                    .join('');
+            if (content)
+                parts.push(`[User]: ${content}`);
+        }
+        else if (msg.role === 'assistant') {
+            const textParts = [];
+            const thinkingParts = [];
+            const toolCalls = [];
+            for (const block of msg.content) {
+                if (block.type === 'text') {
+                    textParts.push(block.text);
+                }
+                else if (block.type === 'thinking') {
+                    thinkingParts.push(block.thinking);
+                }
+                else if (block.type === 'toolCall') {
+                    const args = block.arguments;
+                    const argsStr = Object.entries(args)
+                        .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
+                        .join(', ');
+                    toolCalls.push(`${block.name}(${argsStr})`);
+                }
+            }
+            if (thinkingParts.length > 0) {
+                parts.push(`[Assistant thinking]: ${thinkingParts.join('\n')}`);
+            }
+            if (textParts.length > 0) {
+                parts.push(`[Assistant]: ${textParts.join('\n')}`);
+            }
+            if (toolCalls.length > 0) {
+                parts.push(`[Assistant tool calls]: ${toolCalls.join('; ')}`);
+            }
+        }
+        else if (msg.role === 'toolResult') {
+            const content = msg.content
+                .filter((c) => c.type === 'text')
+                .map((c) => c.text)
+                .join('');
+            if (content) {
+                parts.push(`[Tool result]: ${content}`);
+            }
+        }
+    }
+    return parts.join('\n\n');
+}
+// ============================================================================
+// Summarization System Prompt
+// ============================================================================
+export const SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarization assistant. Your task is to read a conversation between a user and an AI coding assistant, then produce a structured summary following the exact format specified.
+
+Do NOT continue the conversation. Do NOT respond to any questions in the conversation. ONLY output the structured summary.`;
+//# sourceMappingURL=utils.js.map

package/dist/core/defaults.js

@@ -0,0 +1,6 @@
+export const VALID_THINKING_LEVELS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh'];
+export function isValidThinkingLevel(level) {
+    return VALID_THINKING_LEVELS.includes(level);
+}
+export const DEFAULT_THINKING_LEVEL = 'medium';
+//# sourceMappingURL=defaults.js.map

package/dist/core/diagnostics.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=diagnostics.js.map

package/dist/core/event-bus.js

@@ -0,0 +1,25 @@
+import { EventEmitter } from 'node:events';
+export function createEventBus() {
+    const emitter = new EventEmitter();
+    return {
+        emit: (channel, data) => {
+            emitter.emit(channel, data);
+        },
+        on: (channel, handler) => {
+            const safeHandler = async (data) => {
+                try {
+                    await handler(data);
+                }
+                catch (err) {
+                    console.error(`Event handler error (${channel}):`, err);
+                }
+            };
+            emitter.on(channel, safeHandler);
+            return () => emitter.off(channel, safeHandler);
+        },
+        clear: () => {
+            emitter.removeAllListeners();
+        }
+    };
+}
+//# sourceMappingURL=event-bus.js.map

package/dist/core/exec.js

@@ -0,0 +1,71 @@
+/**
+ * Shared command execution utilities for extensions and custom tools.
+ */
+import { spawn } from 'node:child_process';
+/**
+ * Execute a shell command and return stdout/stderr/code.
+ * Supports timeout and abort signal.
+ */
+export async function execCommand(command, args, cwd, options) {
+    return new Promise((resolve) => {
+        const proc = spawn(command, args, {
+            cwd,
+            shell: false,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        let killed = false;
+        let timeoutId;
+        const killProcess = () => {
+            if (!killed) {
+                killed = true;
+                proc.kill('SIGTERM');
+                // Force kill after 5 seconds if SIGTERM doesn't work
+                setTimeout(() => {
+                    if (!proc.killed) {
+                        proc.kill('SIGKILL');
+                    }
+                }, 5000);
+            }
+        };
+        // Handle abort signal
+        if (options?.signal) {
+            if (options.signal.aborted) {
+                killProcess();
+            }
+            else {
+                options.signal.addEventListener('abort', killProcess, { once: true });
+            }
+        }
+        // Handle timeout
+        if (options?.timeout && options.timeout > 0) {
+            timeoutId = setTimeout(() => {
+                killProcess();
+            }, options.timeout);
+        }
+        proc.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (options?.signal) {
+                options.signal.removeEventListener('abort', killProcess);
+            }
+            resolve({ stdout, stderr, code: code ?? 0, killed });
+        });
+        proc.on('error', (_err) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (options?.signal) {
+                options.signal.removeEventListener('abort', killProcess);
+            }
+            resolve({ stdout, stderr, code: 1, killed });
+        });
+    });
+}
+//# sourceMappingURL=exec.js.map

package/dist/core/export-html/ansi-to-html.js

@@ -0,0 +1,256 @@
+/**
+ * ANSI escape code to HTML converter.
+ *
+ * Converts terminal ANSI color/style codes to HTML with inline styles.
+ * Supports:
+ * - Standard foreground colors (30-37) and bright variants (90-97)
+ * - Standard background colors (40-47) and bright variants (100-107)
+ * - 256-color palette (38;5;N and 48;5;N)
+ * - RGB true color (38;2;R;G;B and 48;2;R;G;B)
+ * - Text styles: bold (1), dim (2), italic (3), underline (4)
+ * - Reset (0)
+ */
+// Standard ANSI color palette (0-15)
+const ANSI_COLORS = [
+    '#000000', // 0: black
+    '#800000', // 1: red
+    '#008000', // 2: green
+    '#808000', // 3: yellow
+    '#000080', // 4: blue
+    '#800080', // 5: magenta
+    '#008080', // 6: cyan
+    '#c0c0c0', // 7: white
+    '#808080', // 8: bright black
+    '#ff0000', // 9: bright red
+    '#00ff00', // 10: bright green
+    '#ffff00', // 11: bright yellow
+    '#0000ff', // 12: bright blue
+    '#ff00ff', // 13: bright magenta
+    '#00ffff', // 14: bright cyan
+    '#ffffff' // 15: bright white
+];
+/**
+ * Convert 256-color index to hex.
+ */
+function color256ToHex(index) {
+    // Standard colors (0-15)
+    if (index < 16) {
+        return ANSI_COLORS[index];
+    }
+    // Color cube (16-231): 6x6x6 = 216 colors
+    if (index < 232) {
+        const cubeIndex = index - 16;
+        const r = Math.floor(cubeIndex / 36);
+        const g = Math.floor((cubeIndex % 36) / 6);
+        const b = cubeIndex % 6;
+        const toComponent = (n) => (n === 0 ? 0 : 55 + n * 40);
+        const toHex = (n) => toComponent(n).toString(16).padStart(2, '0');
+        return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+    }
+    // Grayscale (232-255): 24 shades
+    const gray = 8 + (index - 232) * 10;
+    const grayHex = gray.toString(16).padStart(2, '0');
+    return `#${grayHex}${grayHex}${grayHex}`;
+}
+/**
+ * Escape HTML special characters.
+ */
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+}
+function createEmptyStyle() {
+    return {
+        fg: null,
+        bg: null,
+        bold: false,
+        dim: false,
+        italic: false,
+        underline: false
+    };
+}
+function styleToInlineCSS(style) {
+    const parts = [];
+    if (style.fg)
+        parts.push(`color:${style.fg}`);
+    if (style.bg)
+        parts.push(`background-color:${style.bg}`);
+    if (style.bold)
+        parts.push('font-weight:bold');
+    if (style.dim)
+        parts.push('opacity:0.6');
+    if (style.italic)
+        parts.push('font-style:italic');
+    if (style.underline)
+        parts.push('text-decoration:underline');
+    return parts.join(';');
+}
+function hasStyle(style) {
+    return (style.fg !== null ||
+        style.bg !== null ||
+        style.bold ||
+        style.dim ||
+        style.italic ||
+        style.underline);
+}
+/**
+ * Parse ANSI SGR (Select Graphic Rendition) codes and update style.
+ */
+function applySgrCode(params, style) {
+    let i = 0;
+    while (i < params.length) {
+        const code = params[i];
+        if (code === 0) {
+            // Reset all
+            style.fg = null;
+            style.bg = null;
+            style.bold = false;
+            style.dim = false;
+            style.italic = false;
+            style.underline = false;
+        }
+        else if (code === 1) {
+            style.bold = true;
+        }
+        else if (code === 2) {
+            style.dim = true;
+        }
+        else if (code === 3) {
+            style.italic = true;
+        }
+        else if (code === 4) {
+            style.underline = true;
+        }
+        else if (code === 22) {
+            // Reset bold/dim
+            style.bold = false;
+            style.dim = false;
+        }
+        else if (code === 23) {
+            style.italic = false;
+        }
+        else if (code === 24) {
+            style.underline = false;
+        }
+        else if (code >= 30 && code <= 37) {
+            // Standard foreground colors
+            style.fg = ANSI_COLORS[code - 30];
+        }
+        else if (code === 38) {
+            // Extended foreground color
+            if (params[i + 1] === 5 && params.length > i + 2) {
+                // 256-color: 38;5;N
+                style.fg = color256ToHex(params[i + 2]);
+                i += 2;
+            }
+            else if (params[i + 1] === 2 && params.length > i + 4) {
+                // RGB: 38;2;R;G;B
+                const r = params[i + 2];
+                const g = params[i + 3];
+                const b = params[i + 4];
+                style.fg = `rgb(${r},${g},${b})`;
+                i += 4;
+            }
+        }
+        else if (code === 39) {
+            // Default foreground
+            style.fg = null;
+        }
+        else if (code >= 40 && code <= 47) {
+            // Standard background colors
+            style.bg = ANSI_COLORS[code - 40];
+        }
+        else if (code === 48) {
+            // Extended background color
+            if (params[i + 1] === 5 && params.length > i + 2) {
+                // 256-color: 48;5;N
+                style.bg = color256ToHex(params[i + 2]);
+                i += 2;
+            }
+            else if (params[i + 1] === 2 && params.length > i + 4) {
+                // RGB: 48;2;R;G;B
+                const r = params[i + 2];
+                const g = params[i + 3];
+                const b = params[i + 4];
+                style.bg = `rgb(${r},${g},${b})`;
+                i += 4;
+            }
+        }
+        else if (code === 49) {
+            // Default background
+            style.bg = null;
+        }
+        else if (code >= 90 && code <= 97) {
+            // Bright foreground colors
+            style.fg = ANSI_COLORS[code - 90 + 8];
+        }
+        else if (code >= 100 && code <= 107) {
+            // Bright background colors
+            style.bg = ANSI_COLORS[code - 100 + 8];
+        }
+        // Ignore unrecognized codes
+        i++;
+    }
+}
+// Match ANSI escape sequences: ESC[ followed by params and ending with 'm'
+const ANSI_REGEX = /\x1b\[([\d;]*)m/g;
+/**
+ * Convert ANSI-escaped text to HTML with inline styles.
+ */
+export function ansiToHtml(text) {
+    const style = createEmptyStyle();
+    let result = '';
+    let lastIndex = 0;
+    let inSpan = false;
+    // Reset regex state
+    ANSI_REGEX.lastIndex = 0;
+    let match = ANSI_REGEX.exec(text);
+    while (match !== null) {
+        // Add text before this escape sequence
+        const beforeText = text.slice(lastIndex, match.index);
+        if (beforeText) {
+            result += escapeHtml(beforeText);
+        }
+        // Parse SGR parameters
+        const paramStr = match[1];
+        const params = paramStr ? paramStr.split(';').map((p) => parseInt(p, 10) || 0) : [0];
+        // Close existing span if we have one
+        if (inSpan) {
+            result += '</span>';
+            inSpan = false;
+        }
+        // Apply the codes
+        applySgrCode(params, style);
+        // Open new span if we have any styling
+        if (hasStyle(style)) {
+            result += `<span style="${styleToInlineCSS(style)}">`;
+            inSpan = true;
+        }
+        lastIndex = match.index + match[0].length;
+        match = ANSI_REGEX.exec(text);
+    }
+    // Add remaining text
+    const remainingText = text.slice(lastIndex);
+    if (remainingText) {
+        result += escapeHtml(remainingText);
+    }
+    // Close any open span
+    if (inSpan) {
+        result += '</span>';
+    }
+    return result;
+}
+/**
+ * Convert array of ANSI-escaped lines to HTML.
+ * Each line is wrapped in a div element.
+ */
+export function ansiLinesToHtml(lines) {
+    return lines
+        .map((line) => `<div class="ansi-line">${ansiToHtml(line) || '&nbsp;'}</div>`)
+        .join('\n');
+}
+//# sourceMappingURL=ansi-to-html.js.map